When you write the NamedPtr constructor, you have to transfer the values of the parameters to the corresponding
\ndata members. There are two ways to do this. The first is to use the member initialization list:<\/p>\n
\ntemplate<class T>\nNamedPtr<t>::NamedPtr(const string& initName, T *initPtr )\n: name(initName), ptr(initPtr)\n{}\n<\/pre>\nThe second is to make assignments in the constructor body:<\/p>\n
\ntemplate<class T>\nNamedPtr<t>::NamedPtr(const string& initName, T *initPtr)\n{\n name = initName;\n ptr = initPtr;\n}\n<\/pre>\nThere are important differences between these two approaches.
\nFrom a purely pragmatic point of view, there are times when the initialization list must be used. In particular,
\nconst and reference members may only be initialized, never assigned. So, if you decided that a NamedPtr
\nobject could never change its name or its pointer, you might follow the advice of Item 21 and declare the
\nmembers const:<\/p>\n\ntemplate<class T>\nclass NamedPtr {\npublic:\n NamedPtr(const string& initName, T *initPtr);\n...\nprivate:\n const string name;\n T * const ptr;\n};\n<\/pre>\nThis class definition requires that you use a member initialization list, because const members may only be
\ninitialized, never assigned.
\nYou’d obtain very different behavior if you decided that a NamedPtr object should contain a reference to an
\nexisting name. Even so, you’d still have to initialize the reference on your constructors’ member initialization
\nlists. Of course, you could also combine the two, yielding NamedPtr objects with read-only access to names
\nthat might be modified outside the class:<\/p>\n\ntemplate<class T>\nclass NamedPtr {\npublic:\n NamedPtr(const string& initName, T *initPtr);\n...\nprivate:\n const string& name; \/\/ must be initialized via\n \/\/ initializer list\n T * const ptr; \/\/ must be initialized via\n \/\/ initializer list\n};\n<\/pre>\nThe original class template, however, contains no const or reference members. Even so, using a member
\ninitialization list is still preferable to performing assignments inside the constructor. This time the reason is
\nefficiency. When a member initialization list is used, only a single string member function is called. When
\nassignment inside the constructor is used, two are called. To understand why, consider what happens when you
\ndeclare a NamedPtr object.
\nConstruction of objects proceeds in two phases:
\n1. Initialization of data members. (See also Item 13.)
\n2. Execution of the body of the constructor that was called.
\n(For objects with base classes, base class member initialization and constructor body execution occurs prior to
\nthat for derived classes.)<\/p>\n","protected":false},"excerpt":{"rendered":"When you write the NamedPtr constructor, you have to transfer the values of the parameters to the corresponding data members. There are two ways to do this. The first is to use the member initialization list: template<class T> NamedPtr<t>::NamedPtr(const string& initName, T *initPtr ) : name(initName), ptr(initPtr) {} The second is to make assignments in … <\/p>\n