C++ 类 构造函数 constructor

构造函数

    当定义了一个整型变量：

  int a;

    这会申请了一块内存空间来存储a，但是这块内存中原本有数据的，可能是任何值，这不是你所希望的，若你就希望a表示1，所以要把a的值赋值为1。

  int a = 1;

例：

#include <iostream>
using namespace std;
class Date
{
    int d, m, y;
public:
    void init(int dd, int mm, int yy)
    {
        d = dd;
        m = mm;
        y = yy;
    };
    void add_year(int n)
    {
        y+=n;
    }
    void add_month(int n)
    {
        m+=n;
    }
    void add_day(int n)
    {
        d+=n;
    }
    void show()
    {
        cout<<y<<" "<<m<<" "<<d;
    }
};
int main( )
{
    Date today;
    today.init(11,11,2011);
    Date tomorrow = today;
    tomorrow.add_day(1);
    tomorrow.show();
    return 0;
}

程序执行结果为：
    2011 11 11
若对对象未进行初始化，则：

int main( )
{
    Date today;
      // today.init(12,12,2001);
      Date tomorrow = today;  // warning C4700: 使用了未初始化的局部变量“today”
      tomorrow.add_day(1); 
      tomorrow.show();
      return 0;
}

程序执行结果为：
-858993460 -858993460 -858993459
可见，程序设计的悲哀是对不确定的状态进行了确定的操作。

一个好办法是允许程序员声明一个函数显示地（the explict purpose）去初始化（initializing）对象。类的对象是这个类的一个实例，也称为类变量。和基本数据类型变量一样，也可以为其数据成员赋初值，不过对象的初始化比较复杂，其中最重要的方式就是构造函数（constructor）。

 

类的数据成员是不能在声明类时初始化的。

class Date
{
    int d = 1;  // error C2864: “Date::d”: 只有静态常量整型数据成员才可以在类中初始化
    int m = 10;  // error C2864: “Date::d”: ……
    int y = 1949; // error C2864: “Date::d”: ……
}

 

如果一个类中所有的成员都是公用的，如：

如果一个类中所有的成员都是公用的，如：
class Date
{
public:
    int d, m, y;
}
Date today = {11,11,2011};     // 将today初始化为d:11，m:11，y:2011

这和结构体变量的初始化是差不多的，但这种方法无法初始化私有成员。

class Date
{
private:
    int d, m, y;
}
Date today = {11,11,2011};  // error C2552:“today”: 不能用初始值设定项列表初始化非聚合

如果数据成员是私有的，该如何进行初始化？可以通过类的一个公有接口来进行“初始化”，即调用一个公共的成员函数来“初始化”，严格地说，这是赋值而不是初始化。

最好的方法是通过构造函数来进行初始化，类的构造函数由编译器自动调用，而不是由程序员调用。
它承担的任务是：实例（对象）的生成与初始化。构造函数是类中的一种特殊函数，当一个类被创建时自动被调用。
构造函数用于初始化数据成员和执行其它与创建对象有关的合适的处理过程。
构造函数是一个与其所在的类同名的函数。

class Date
{
    int d, m, y;
public:
    Date(int dd, int mm, int yy)  // 构造函数，初始化类的私有成员d、m、y
    {
        d = dd;
        m = mm;
        y = yy;
    };
};

构造函数大体可分为两类：
（1）缺省构造函数(the default constructor)，无调用参数。
（2）参数化的构造函数(the parameterized constructor)，有调用参数。

class Person
{
public:
    Person( );              // 缺省构造函数
    Person( const string& n );  // 复制构造函数
    Person(......);            // 参数化的构造函数
private:
    string name;
};

 

构造函数没有返回值，连void也不行。

class Person
{
public:
    void Person( );         // error
};

编译上边的Person类，会出现下面的错误提示：
    error C2380: “Person”前的类型(构造函数有返回类型或是当前类型名称的非法重定义?)
类的构造函数可以被重载(be overloaded)。但是, 每个构造函数必须有不同的函数签名。当类的一个实例创建时，一个合适的构造函数被自动调用。一个类中可以根据需要定义多个构造函数，编译程序根据调用时实参的数目、类型和顺序自动找到与之匹配者。

class Date
{
    int d, m, y;
public:
    Date(int dd, int mm, int yy);
    Date(int dd, int mm);    // today's year
    Date(int dd);        // today's month and year
    Date( );        // default Date: today
    Date(const char* p);    // date in string representation
    /* ... */
};
void main( )
{
    Date today(11);             // 调用Date(int dd)
    Date today(11, 11);           // 调用Date(int dd, int mm)
    Date july4("November 11, 2011");    // 调用Date(const                         char* p)
    Date now;                 // 调用Date( )
    /* ...*/
}

 

在实际程序设计中，有时很难估计将来对构造函数形参的组合会有怎样的要求，一种有效的策略是对构造函数也声明有省缺值的形参（Default Arguments）。

例：

class Date
{
    int d, m, y;
public:
    Date(int dd = 0, int mm = 0, int yy = 0);
    /* ... */
};
int main( )
{
    Date today(11);         // dd = 11, int mm = 0, int yy = 0
    Date someDay(11, 11);   // dd = 11, int mm = 11, int yy = 0
    Date aDay(11, 11, 2011);  // dd = 11, int mm = 11, int yy = 2011
    Date now;             // dd = 0, int mm = 0, int yy = 0
    /* ...*/
    return 0;
}

 

在创建一类的对象数组时，对于每一个数组元素，都会执行缺省的构造函数。

#include <iostream>
using namespace std;
unsigned count = 0;
class A
{
public:
    A ( )
    {
        cout << "Creating A " << ++count <<endl;
    }
};
int main( )
{
    A ar[3];  // 对象数组
    return 0;
}

执行结果为：
"Creating A " 1
"Creating A " 2
"Creating A " 3

通常将构造函数的声明置于public中，假如将其放入private区段中会发生什么后果？这将会将构造函数成为私有的，那将意味什么？

例：将构造函数声明为private。

class Date
{
private:
    int  d, m, y;
    Date( )
    {
        d = 11;
        m = 11;
        y = 2011;
    }
};
int main( )
{
    Date today;  // error C2248: “Date::Date”: 无法访问 private 成员(在“Date”类中声明)
    return 0;
}

 

    在上例中，将默认构造函数声明成private，这样便限制了无参数的Date对象创建。我们知道，当我们在程序中声明一个对象时，编译器为调用构造函数（如果有的话），而这个调用将通常是外部的，也就是说它不属于class对象本身的调用，假如构造函数是私有的，由于在class外部不允许访问私有成员，所以这将导致编译出错。若构造函数声明成private，可以使用该类的友元函数或者友元类创建其对象，详见后面友元部分。

 

例：这里举一个通过构造函数来限制类对象创建的例子。（Restricting Object Creation Through Constructor）

class Emp
{
public:
    Emp( unsigned ID )
    {
        id = ID;
    }
    //…
private:
    unsigned id;
    // Emp( );
};

int main( )
{
    Emp elvis;//  Error: no public default constructor
    Emp cher( 111222333 );
    return 0;
}

 

除以下两种情况外，编译器为一个类提供一个public型的缺省构造函数。
（1）如果一个类声明任何一个构造函数，则编译器不提供 public型的缺省构造函数。 如果需要有一个缺省构造函数的话，程序员必须自己编写一个缺省构造函数。
（2）如果一个类声明了一个非公有的缺省构造函数，则编译器不提供缺省构造函数（如上例）。

The compiler provides a public default constructor for a class with two exception:
If a class explicitly declare any constructor, the complier does not provide a public default constructor. In this case, the programmer must provide a public default constructor if desired.
If a class declares a nonpublic default constructor, the complier does not provide a public default constructor.

 

class Date
{
    int d, m, y;
public:
    Date(int dd, int mm, int yy)
    {
        d = dd;
        m = mm;
        y = yy;
    }
};
int main( )
{
    Date today = Date(12,12,2001);    //OK
    Date this_day(12,12,2001);       //OK
    Date my_birthday;  // error C2512: “Date”: 没有合适的默认构造函数可用
    /* ...*/
    return 0;
}

有一个有参数化的构造函数Date(int dd, int mm, int yy)，编译器将不再提供默认的构造函数，因此创建Date对象必须给出3个int型参数，而无参数的my_birthday无法创建。