Looks like there's a typo in delegating constructors slide. Author writes X when he meant A.

FaTony, thank you.
here is corrected version: http://sdrv.ms/W2pck2
Admin, please, re-upload.

fixed. Please, let me know if you find any other typos!
thx.

Using "auto" everywhere possible is like using the word "stuff" in every sentence instead of the proper term. Sure one can deduce what was meant, but readability suffers because "something" is meaningless without context. Redundancy facilitates understanding, especially for humans...

Few corrections and notes regarding C++03 examples.

Site screenshot, and page 27:

C++03:

int a[]= {1, 2, 3, 4, 5};

// or vector<int> v(a, a+5);
vector<int> v(a, a+ sizeof(a)/sizeof(*a));

----------------------------------------------------------------


Pages 2-3:

In C++03, instead of

foo(NULL);


foor(0) is prefered .


However the point is the same, nullptr is better.



Pages 4-5:

In C++03 the following applies:

sizeof(char) == sizeof(unsigned char)== sizeof(signed char)==1 byte (== numeric_limits<unsigned char>::digits bits)



Page 11:

C++03 provides assert() for run-time assertions, in <cassert>, <assert.h>.

The template function could be implemented as:

template<class T>
void f(T v)
{
assert(sizeof(v)==4);

//do something with v
}


Of course, C++11 compile-time assertion is better.


Pages 15-17: C++03 provides pointers to functions and member functions, but C++11 new keywords are probably better.


Page 45: In C++03 0xD0U is hexadecimal unsigned, not 0xD0.


Page 51: The last line of C++03 code, in a clearer format:

// or, sort(a, a + sizeof(a)/sizeof(a[0]));
sort( a, a + sizeof(a)/sizeof(*a));

Few corrections and notes regarding C++03 examples:

http://cppsoftware.binhoster.com/documents/cpp03_corrections_and_notes.txt

A couple of corrections, and notes regarding C++03 examples.

Site screenshot, and page 27:

C++03:

int a[]= {1, 2, 3, 4, 5};



// or vector<int> v(a, a+5);

vector<int> v(a, a+ sizeof(a)/sizeof(*a));

Pages 2-3:

In C++03, instead of

foo(NULL);

foo(0);

is preferred.


However the point is the same, nullptr is better.



Pages 4-5:

In C++03 the following applies:

sizeof(char) == sizeof(unsigned char)== sizeof(signed char)==1 byte (== numeric_limits<unsigned char>::digits   bits)

Page 11:

C++03 provides assert() for run-time assertions, in <cassert>, <assert.h>.

The template function could be implemented as:

template<class T>

void f(T v)

{

  assert(sizeof(v)==4);

 

  //do something with v

}

Of course, C++11 compile-time assertion is better.


Pages 15-17: C++03 provides pointers to functions and member functions, but C++11 new keywords are probably better.


Page 45: In C++03 0xD0U, and 0xD0u, is hexadecimal unsigned, not 0xD0.


Page 51: The last line of C++03 code, in a clearer format:

// or, sort(a, a + sizeof(a)/sizeof(a[0])); 

sort(a, a + sizeof(a)/sizeof(*a));

I think the forum needs better formatting tools for comments.

I'm a big fan of "auto" but the guideline that says to use prefer using it in

auto p = new T();

is wrong. Indeed, the type of p is T* and, most likely, the programmer want it to be a smart pointer like, say, unique_ptr<T>. While waiting the standardization of make_unique, one should use

unique_ptr<T> p = new T();

On the other hand,

auto p = make_shared<T>(arg1);

is right because make_shared<T> returns a shared_ptr<T>.