Class

1. default constructor (constructor with no arguments), if no any constructor is defined (but for simple data type, there is no initialization of each data member to the default value of its associated type). If any constructor is defined, regardless of specific (have arguments) or default constructor, C++ will not generate default constructor automatically. So if default constructor is required, it need to be defined explicitly.
2. destructor
3. copy constructor
4. assignment operator (operator=)

The words constructor and destructor are somewhat misleading in that these programmer-supplied functions neither construct nor destroy the objects of the class to which they are applied by the compiler automatically. The constructors of a class serve primarily to initialize the data members of the class object. The destructor primarily frees any resources acquired by the class object during its lifetime.

class ClassName {
public:
  ClassName(double member1 = 0.0, int member2 = 0)
  : member1_(member1), member2_(member2) {
  }
  // or
  ClassName(double member1 = 0.0, int member2 = 0) {
    member1_ = member1;
    member2_ = member2;
  }

protected:
  double member1_;
  int member2_;
};

// usage in application
ClassName c1; // not c1()! c1() is not default constructor!
ClassName c2(-0.7, 2);
ClassName c3 = Account(3.5);
ClassName c4 = 10; // can only specify single (first) argument

If there is any constrcutor taken argument, default constructor need to be provided explicitly. Although there is no appropriate default values for some classes to allow default constructor, in practice it is almost always necessary to provide beacuse the container classes (e.g. vector), array and dynamic array require default constructor to initialize their elements. In this case, the best is to initialize the object to indicate that it is not yet initialized with a valid set of values (NULL for pointer, 0 for number). Then need to program checks within all member functions to guarantee the integrity of the class object prior to its use (user must explicitly set valid value through modify member function).

The difference of member initialization list and assignment of the data members within the body of the constructor is the former is an initialization while the later is an assignment (initialization is done using default constructor). For efficiency, member class object (non-built-in data type) should always be initialized in the member initialization list, or no need to explicitly initialize (use default constructor).

const and reference data members must always be initialized in the member initialization list; otherwise, a compile-time error results. The order of initialization is determined by the class declaration order of the members, not the order of member initialization list. Mis-understand this can lead to difficult-to-uncover error when using one class member to intialize another. It is recommended to list members in an initialization list in the order in which they are declare.

string s1; // initialization
string s2("Hello"); // initialization
string s3 = s2; // initialization
s1 = s3; // assignment

From a purely operational point of view, the difference between initialization and assignment is that the former is performed by a constructor while the latter is performed by operator=. In other words, the two processes correspond to different function calls.

The reason for the distinction is that the two kinds of functions must worry about different things. Constructors usually have to check their arguments for validity, whereas most assignment operators can take it for granted that their argument is legitimate (because it has already been constructed). On the other hand, the target of an assignment, unlike an object undergoing construction, may already have resources allocated to it. These resources typically must be released before the new resources can be assigned. Frequently, one of these resources is memory. Before an assignment operator can allocate memory for a new value, it must first deallocate the memory that was allocated for the old value.

Pass-by-value means "call the copy constructor."

ClassName(const ClassName& original);

// usage in application
ClassName c2(c1), c4 = c3;	// just like: int i(-4), j = i;
ClassName c5 = Function(c1);	// pass/return by value

1. Object passed or returned by value has sizeof ClassName bytes, thus an inefficient use of storage to copy objects whose size in bytes is large.
2. An object is copied through a call to the copy constructor, which means that passing or returning an object by value involves a method call. If the copy constructor does a large amount of processing, the process may be very time-consuming.

The call to the copy constructor may be not obvious from the source code when it is generated by the compiler. Accordingly, it is easy for the programmer to forget the overhead associated with passing or returning by value. The class designer can disable passing or returning by value for functions outside the class by defining it as private.

~ClassName(void);

String(const char s[]); // convert constructor

class String {
public:
  explicit String(const char s[]);
};

class ClassName {
public:
  ClassName(void) {
    Initialize();
  }
  ~ClassName(void) {
    Clean();
  }
  ClassName(const ClassName& original) {
    Initialize();
    (*this) = original;	// use operator=()
  }

protected:
  int member1_;
  double *member2_;

  Initialize(void) {
    member1_ = 0;
    member2_ = NULL;
  }
  Clean(void) {
    if ( member2_ != NULL )
      delete member2_;
    Initialize();
  }
};

class ClassName {
private:
  ClassName(const ClassName& original);
  ClassName& operator=(const ClassName& original);
};

class ClassName {
public:
  member1type GetMember1(void) const { return member1_; }
  member2type GetMember2(void) const { return member2_; }
  void SetMember1(member1type member1) { member1_ = member1; }
  void SetMember2(member2type member2) { member2_ = member2; }

protected:
  member1type member1_;
  member2type member2_;
};

// usage in application
c2.SetMember2(c1.GetMember1());

class String {
public:
  String(const char *str);
  operator char *() const { return str_; }
  char& operator[](int index) const { return str_[index]; }

protected:
  char *str_;
};

const String cs("Hello World");
char *str = cs; // call cs.operator char*()
strcpy(str, "Hi World!"); // modify what str points to!
String s = "I'm not constant";
s[0] = 'x'; // OK
cs[0] = 'x'; // modify const string without complaint!

class ClassName {
public:
  const member1type* GetMember1() const {
    return (const member1type*)member1_;
  }

protected:
  member1type *member1_;
};

// usage in application
ClassName c1;
member1type *pc1 = c1.GetMember1(); // error: cannot convert const* to *
const member1type *pc2 = c1.GetMember1(); // OK
cout << c1.GetMember1() << endl; // OK

class ClassName {
public:
  member1type* GetMember1(void) {
    return member1_;
  }

protected:
  member1type *member1_;
};

// usage in application
ClassName c1;
member1type *pc1 = c1.GetMember1(); // OK
const ClassName cc1;
const member1type *pc2 = cc1.GetMember1(); // error: member function not const
cout << c1.GetMember1() << endl; // OK

Or provide two member functions serve for non-const and const object, such as indexing operator.

class String {
public:
  String(const char *str);
  operator const char *() const { return str_; }

protected:
  char *str_;
};

String GetStr(void)
{
    return "Hello World";
}                

const char *pc = GetStr(); // pc points to temporary String object
// temporary String object destroyed
cout << pc; // result undefined

Member function can declare inline either during declaration in class definition or its definition. However, since inline functions must be defined in every text file in which they are called, inline member function that is not defined in class header file must be placed in class definition.

Constant class object can only access constant member function, that has const keyword is placed between the parameter list and the body of the member function to mark data member as read only. The keyword must be specified in both its declaration and its definition. Constructors and destructors are exceptions in that, even though they are never constant member functions, they can be called by constant class object. Its const-ness start from the time its construction completes to the time its destruction starts.

Constant member function can be overloaded with a non-const member function that has the same parameter list. The const-ness of the class object determines which function is invoked.

class ClassName {
public:
  void Bad(const string& str) const
private:
  char *text_;
};

void ClassName::Bad(const string& str) const
{
  text_ = str.c_str(); // error: text_ cannot be modified
  for (int i=0; i<str.size(); i++)
    text_[i] = str[i]; // bad style but not an error
}

There are two prevailing notions of constness:

1. bitwise constness - a member function is const if and only if it doesn't modify any of the object's data members (excluding those that are static). The nice thing about bitwise constness is that it is easy to detect violations: compilers just look for assignments to data members. It is C++'s definition of constness.
2. conceptual constness - a const member function might modify some of the bits in the object on which it's invoked, but only in ways that are undetectable by clients. The solution of this kind of bitwise-constness-is-not-quite-what-I-had-in-mind problem is mutable data member.

class Screen {
public:
  inline void Move(int r, int c) const;
private:
  string screen_;
  mutable string::size_type cursor_; // mutable member
  short width_;
  short height_;
};

void Screen::Move(int r, int c) const
{
 if (CheckRange(r, c))
 {
   int row = (r-1) * width_;
   cursor_ = row + c - 1; // modify cursor_
 }
}

This is logical, because modifying cursor_ is necessary to inspect the content of Screen object and does not modify the content of the Screen itself.

A friend may be a namespace function, a member function of another previously defined class or an entire class. In making one class a friend, all the member functions of the friend class are given access to the nonpublic members of the class granting friendship.

Since friends are not members of the class granting friendship, they are not affected by the public, private or protected section in which they are declared within the class body.

• Operator cannot be overloaded:
  • sizeof - because built-in operations such as incrementing a pointer into an array implicitly depends on it. Thus, it could not be given a new and different meaning by the programmer without violating basic language rules.
  • ?: - no need and the overloading expr1 ? expr2 : expr3 would not be able to guarantee that only one of exper2 and expr3 was executed.
  • :: - in N::m neither N nor m are expressions with values; N and m are names known to the compiler and :: performs a (compile time) scope resolution rather than an expression evaluation. One could imagine allowing overloading of x::y where x is an object rather than a namespace or a class, but that would contrary to first appearences - involve introducing new syntax (to allow expr::expr). It is not obvious what benefits such a complication would bring.
  • .(dot) - in principle be overloaded using the same technique as used for ->. However, doing so can lead to questions about whether an operation is meant for the object overloading . or an object referred to by .

    class Y {
    public:
      void f();
      // ...
    };
    
    class X {
      Y* p;
      Y& operator.() { return *p; } // assume that you can overload .
      void f();
      // ...
    };
    
    void g(X& x)
    {
      x.f(); // X::f or Y::f or error?
    }
    

  • .* - pointer to class data member or member function.
• Operator best no overloaded:
  • && and || - because it will replace short-circuit semantics with function call semantics: if (expression1 && expression2) ... becomes if (expression1.operator&&(expression2)) ... when implemented as member function or if (operator&&(expression1, expression2)) ... when implemented as friend function. When a function call is made, both expressions are evaluated. There is no way of knowing whether which one will be evaluated first, needless to say can ensure it is evaluated in left-to-right order.
  • , - An expression containing a comma is evaluated by first evaluating left part of the comma, then the right part; the result of the overall comma expression is the return value of the right expression. There is no way to mimic this behaviour because never be able to guarantee the left-hand expression is evaluated before the right-hand expression, even as member function, because compilers are not constrained (by C++ specification) to do things that way.
• =, [], () and -> must be implemented as member function.
• If left operand of the operator must be a type different from the class, then friend function must be used, such as << and >>.
• Arithmetic operator should be implemented as friend function if no alteration should be made on both operand, instead a new object is constructed and returned, such as c1 = c2 + c3;.
• Otherwise both also can. Implementation using friend function will automaticlly convert passed argument to the class value (if there is one constructor take that type of argument) if it is not same type to the class. Example, 0.0 < temperature1 is evaluated as operator<(0.0, temperature1), if there is a constructor Temperature(double t);, it is evaluated as operator<(Temperature(0.0),temperature1); using member function, it is evaluated as (0.0).operator<(temperature1), result compilation error. Symmetric operators, such as operator==, are best defined as friend function if either operand can be of class type while implementation using member function is safer as it forces explicit conversion: Temperature(0.0) < temperature1.

1. deallocate old info if necessary to avoid memory leak
2. new allocation and assertion of success
3. copy info over

ClassName& Classname::operator=(const ClassName& original)
{
  if (this == &original) return *this; // self-test

  member1_ = original.member1_; // copy scalar member
  // copy other data member ...

  return *this;	// return this object
}

ClassName& c1 = c2, *pc3 = &c3;
*pc3 = c3; // self-assignment
c2 = c1;   // or vice versa

class BaseName {
  void mf1(BaseName& rb); // rb and *this could be the same
};

void f1(BaseName& rb1, BaseName& rb2); // rb1 and rb2 could be the same

class DerivedName: public BaseName {
  void mf2(BaseName& rb); // rb and *this could be the same
};

int f2(DerivedName& rd, BaseName& rb); // rd and rb could be the same

char& basic_string::operator[](int position); // can be rvalue or lvalue
const char& basic_string::operator[](int position) const; // rvalue only

friend ostream& operator<<(ostream& outStream, const ClassName& c)
{
  // format and output statements ...
  return outStream;
}
friend istream& operator>>(istream& inStream, ClassName& c);
friend fstream& operator<<(fstream& outStream, const ClassName& c);
friend fstream& operator>>(fstream& inStream, ClassName& c);

Screen& Screen::Clear(const char bkground = ' ')
{
 // ...
 return *this;
}
//...

// usage in application
screen1.Clear().Move(2, 2).Set('*').Display();

const ClassName operator+(const ClassName& lhs, const ClassName& rhs)
{
  ClassName result;
  // addition statements ...
  return (const ClassName)result;	// will call copy constructor
}
const ClassName operator-(const ClassName& lhs, const ClassName& rhs);
const ClassName operator*(const ClassName& lhs, const ClassName& rhs);
const ClassName operator/(const ClassName& lhs, const ClassName& rhs);

ClassName& operator++(void);		// prefix, ++c
const ClassName operator++(int);	// postfix c++
ClassName& operator--(void);		// --c
const ClassName operator--(int);	// c--

ClassName& operator+=(int);
ClassName& operator-=(int);

// prefix form
LargeInt& LargeInt::operator++()
{
  *this += 1; // increment
  return *this; // fetch
}

// postfix form
const LargeInt LargeInt::operator++(int) // no use of parameter
{
  LargeInt oldValue = *this; // fetch
  ++(*this); // increment, implemented in terms of their prefix
  return oldValue; // return what was fetche
}

void Add(ClassName& result, const ClassName& lhs, const ClassName& rhs)
{
  // addition statements ...
}

ClassName Function(parametertype parameter)
{
  ClassName result;
  // ...
  return result;
}
// transform into
void Function(Classname& result, parametertype parameter)
{
  // result = ...
}

// relational operation
bool operator==(const ClassName& rhs);
bool operator!=(const ClassName& rhs);
bool operator<(const ClassName& rhs);
bool operator<=(const ClassName& rhs);
bool operator>(const ClassName& rhs);
bool operator>=(const ClassName& rhs);

class ClassName {
public:
  static unsigned GetN(void) const { return n_; } // inline
  static static2type GetStatic2(void);
private:
  static unsigned n_; // count of ClassName objects
  static static2type static2_;
};

unsigned ClassName::n_ = 10;
static2type ClassName::static2_;

static2type ClassName::GetStatic2(void) { // non-inline
  return static2_;
}

ClassName c1;

c1.GetN();
// or
ClassName::GetN();

unsigned n1 = c1.n_;
// or
unsigned n2 = ClassName::n_;

void* operator new(size_t size); // size in bytes
void* operator new[](size_t size); // size in bytes
void* operator new(size_t size, ClassName *p); // for placement new
void* operator new[](size_t size, ClassName *p); // for placement new[]

// either
void operator delete(void *p);
void operator delete[](void *p);
// or
void operator delete(void *p, size_t size);
void operator delete[](void *p, size_t size);

// for exception handling of executing new expression
void operator delete(void *p, ClassName *p);
void operator delete[](void *p, ClassName *p);

// allocate enough raw memory for an array of 10 ClassName objects
void *buffer = operator new[](10 * sizeof(ClassName));
// cArray point to it so it can be treated as an ClassName array
ClassName *cArray = static_cast<ClassName*>(buffer);
// initialize the ClassName objects using placement new
for (int i=0; i<10; ++i)
  new (&cArray[i]) ClassName(IDNum[i]);

// ...

for (int i=9; i>=0; --i)
  cArray[i].~ClassName();
// deallocate the raw memory
operator delete[](buffer);

class B; // forward declaration for class B

class A {
public:
  A(const B&); // an A can be constructed from a B
};

class B {
public:
  operator A(void) const; // a B can be converted to an A
};

// usage in application
void f(const A&);
B b;
f(b); // compiler error: ambiguous

Conversion operator can lead to the wrong function being called. The solution is to replace it with equivalent functions that don't have the syntactically magic names, like B::toA(void). Convert constructor is even worse, as it quietly creates new object result of mistyping function (can be operator overloading function) parameter. That is why explicit keyword is introduced.

1. static: Same to all instance of the class. For integral type generally use anonymous enum (the enum hack should not be used anymore), but in fact can use static data member declaration style and C++ standard support initialization within the class body with a constant integral value (but not Visual C++). Even this case, the constant integral data member must still be defined outside the class body and must not specify an initial value (as already initialized).

2. non-static: Each instance has different value. There is a tricky way to define it using constructor header.

#include <string>
using namespace std;
class ClassName {
public:
  ClassName(void)
  : STR2_("FLOATING") {
    // other initialization
  }
  ClassName(const string& str1)
  : STR2_(str1) {
    // other initialization
  }
  string GetStr1(void) { // no need const string, but must const string&
    return STR2_;
  }
private:
  enum { ONE = 1 };
  static const int TWO;
  static const short THREE = 3;	// VC++ not support
  static const string STR1_;
  const string STR2_;
};

// in implementation file
const int ClassName::TWO = 2;
const short ClassName::THREE; // definition needed, but no initialization
const string ClassName::STR1_ = "FLOATING2";

Why do these inconvenient restrictions exist? A class is typically declared in a header file and a header file is typically included into many translation units. To avoid complicated linker rules, C++ requires that every object has a unique definition. That rule would be broken if C++ allowed in-class definition of entities that needed to be stored in memory as objects.

class Empty { };

int main()
{
  Empty a, b;
  if (&a == &b)
    cout << "impossible: report error to compiler supplier";
  Empty* p1 = new Empty;
  Empty* p2 = new Empty;
  if (p1 == p2)
    cout << "impossible: report error to compiler supplier";
  delete p1;
  delete p2;
  return 0;
}

ClassName * const this; // for non-const member function
const ClassName * const this; // for const member function

c1.SetMember1(member1);
// is translate to
SetMember1(&c1, member1) { this->member1_ = member1; }

To understand what and why have nested class (nested in another class) and local class (defined inside a function body), think them as struct (struct and class is the same in C++) only used inside a class and function. They normally simple (basically data structure and some helper function) and mostly public members (easy for its host to access). Typical example is list node struct/ class inside list class.

The rule of thumb of designing simple interface is only data or functions that are taking any responsibility for maintaining the invariant should be defined as class. The invariant is the valid state of the member variables that need to keep track. Just using the data or functions, but not defending the invariant, doesn't need to be in the class, better be struct or function built on top of existing class.

If the class is full of Set and Get member functions, it seem like an unnecessary layer of abstraction to the data. If there is too many dynamic cast casting from base classes to derived classes, this indicates that there might be too much class hierarchies.

The way the whole thing is conceived is that the constructor establishes the environment for the member functions to operate in, in other words, the constructor establishes the invariant. And since to establish the invariant often have to acquire resources, the destructor will pull down the operating environment and release any resources required.

For example, in vector, size and elements that it hold much be matched. If the function changes the size of a vector, then it need to changes the number of elements stored and move the elements. There must be a member function for that. But given efficient element access, find function for searching in a vector is best provided as a non-member.

In Date class, functions such as find_next_Sunday should not be member function, else the class will be crowded making hard to change the data layout.