Программирование. Принципы и практика использования C++ Исправленное издание, стр. 417

Date d4 = Date(2007*12*31+6*31+5); // OK

f(Date(2007*12*31+6*31+5));        // OK

Если базовые классы или члены производного класса не требуют явных аргументов и в классе нет других конструкторов, то автоматически генерируется конструктор по умолчанию (default constructor). Этот конструктор инициализирует каждый объект базового класса и каждый член, имеющий конструктор по умолчанию (оставляя члены, не имеющие конструкторы по умолчанию, неинициализированными). Рассмотрим пример.

struct S {

  string name, address;

  int x;

};

Этот класс

S
имеет неявный конструктор
S()
, инициализирующий члены name и
address
, но не
x
. 

A.12.3.1. Деструкторы

Смысл операции удаления объекта (т.е. что произойдет, когда объект выйдет за пределы области видимости) можно определить с помощью деструктора (destructor). Имя деструктора состоит из символа

~
(оператор дополнения), за которым следует имя класса.

class Vector { // вектор чисел типа double

public:

  explicit Vector(int s):sz(s),p(new double[s]) { }

  // конструктор

  ~Vector() { delete[] p; }

  // деструктор

  // ...

private:

  int sz;

  double* p;

};

void f(int ss)

{

  Vector v(s);

  // ...

} // при выходе из функции f() объект v будет уничтожен;

  // для этого будет вызван деструктор класса Vector

Деструкторы, вызывающие деструкторы членов класса, могут генерироваться компилятором. Если класс используется как базовый, он обычно должен иметь виртуальный деструктор (см. раздел 17.5.2).

Деструкторы, как правило, используются для “очистки” и освобождения ресурсов. Объекты класса уничтожаются сверху вниз, начиная с кода самого деструктора, за которым следуют члены в порядке их объявления, а затем — объекты базового класса в порядке их объявления, т.е. в порядке, обратном их созданию (см. раздел A.12.3.1).

A.12.3.2. Копирование

Можно определить суть копирования объекта класса.

class Vector { // вектор чисел типа double

public:

  explicit Vector(int s):sz(s), p(new double[s]) { }

  // конструктор

  ~Vector() { delete[] p; }         // деструктор

  Vector(const Vector&);            // копирующий конструктор

  Vector& operator=(const Vector&); // копирующее присваивание

  // ...

private:

  int sz;

  double* p;

};

void f(int ss)

{

  Vector v(s);

  Vector v2 = v; // используем копирующий конструктор

  // ...

  v = v2;        // используем копирующее присваивание

  // ...

}

По умолчанию (т.е. если вы не определили копирующий конструктор и копирующее присваивание) компилятор сам генерирует копирующие операции. По умолчанию копирование производится почленно (см. также разделы 14.2.4 и 18.2). 

A.12.4. Производные классы

Класс можно определить производным от других классов. В этом случае он наследует члены классов, от которых происходит (своих базовых классов).

struct B {

  int mb;

  void fb() { };

};

class D:B {

  int md;

  void fd();

};

В данном случае класс

B
имеет два члена:
mb
и
fb()
, а класс
D
— четыре члена:
mb
,
fb()
,
md
и
fd()
.

Как и члены класса, базовые классы могут быть открытыми и закрытыми (

public
или
private
).

Class DD:public B1,private B2 {

  // ...

};

В таком случае открытые члены класса

B1
становятся открытыми членами класса
DD
, а открытые члены класса
B2
— закрытыми членами класса
DD
. Производный класс не имеет особых привилегий доступа к членам базового класса, поэтому члены класса
DD
не имеют доступа к закрытым членам классов
B1
и
B2
.

Если класс имеет несколько непосредственных базовых классов (как, например, класс

DD
), то говорят, что он использует множественное наследование (multiple inheritance).

Указатель на производный класс

D
можно неявно преобразовать в указатель на его базовый класс
B
при условии, что класс
B
является доступным и однозначным по отношению к классу
D
. Рассмотрим пример.