C++之类和对象(二)

  • 类的默认成员函数

一、构造函数

成员变量为私有的,要对它们进行初始化,必须用一个公有成员函数来进行。同时这个函数应该有且仅在定义对象时自动执行一次,这时 调用的函数称为构造函数(constructor)。

构造函数是特殊的成员函数,其特征如下:
1. 函数名与类名相同。

2. 无返回值。

3. 对象构造(对象实例化)时系统自动调用对应的构造函数。

4. 构造函数可以重载。

5. 构造函数可以在类中定义,也可以在类外定义。

6. 如果类定义中没有给出构造函数,则C++编译器自动产生一个缺省的构造函数,但只要我们定义了一个构造函数,系统就不会自动 生成缺省的构造函数。

7. 无参的构造函数和全缺省值的构造函数都认为是缺省构造函数,并且缺省的构造函数只能有一个。

  • 无参构造函数&带参构造函数
class Date { 
public :     
    // 1.无参构造函数     
    Date ()    
    {}
    // 2.带参构造函数     
    Date (int year, int month , int day ){          
        _year = year ;          
        _month = month ;          
        _day = day ;    
    } 
private :     
    int _year ;     
    int _month ;     
    int _day ; 
};

void TestDate1 () {     
    Date d1 ;               // 调用无参构造函数     
    Date d2 (2018, 1, 1);   // 调用带参的构造函数     
    Date d3 ();             // 注意这里没有调用d3的构造函数定义出 d3
}
  • 带缺省参数的构造函数
class Date { 
public :     
    // 3.缺省参数的构造函数     
    Date (int year = 2000, int month = 1, int day = 1)    {          
        _year = year ;          
        _month = month ;          
        _day = day ;    
    }
     // 4.半缺省参数的构造函数(不常用)     
    Date (int year, int month = 1)    {          
    _year = year ;          
    _month = month ;          
    _day = 1;    
    } 
private :     
    int _year ;     
    int _month ;     
    int _day ; 
};

void Test() {     
    Date d1 ;               // 调用缺省构造函数     
    Date d2 (2018, 7, 23);   // 调用缺省构造函数 
}

二、拷贝构造函数


创建对象时使用同类对象来进行初始化,这时所用的构造函数称为拷贝构造函数(Copy Constructor),拷贝构造函数是特殊的构造函数。

特征:
1. 拷贝构造函数其实是一个构造函数的重载。

2. 拷贝构造函数的参数必须使用引用传参,使用传值方式会引发无穷递归调用。

3. 若未显示定义,系统会默认缺省的拷贝构造函数。缺省的拷贝构造函数会,依次拷贝类成员进行初始化。
 

class Date { 
public :     
    Date()    
    {}

    // 拷贝构造函数     
    Date (const Date& d)    {          
        _year = d ._year;          
        _month = d ._month;          
        _day = d ._day;    
    } 
private :     
    int _year ;     
    int _month ;     
    int _day ; 
};

void TestDate1 () {     
    Date d1 ;

    // 下面两种用法都是调用拷贝构造函数,是等价的。
    Date d2 (d1);    // 调用拷贝构造函数     
    Date d3 = d1;    // 调用拷贝构造函数 
}

三、析构函数

当一个对象的生命周期结束时,C++编译系统会自动调用一个成员函数,这个特殊的成员函数即析构函数(destructor)。

构造函数是特殊的成员函数,其特征如下:

1. 析构函数在类名加上字符 ~ ;

2. 析构函数无参数无返回值;

3. 一个类有且只有一个析构函数。若未显示定义,系统会自动生成缺省的析构函数; 

4. 对象生命周期结束时,C++编译系统系统自动调用析构函数;

5. 注意析构函数体内并不是删除对象,而是做一些清理工作。

有些析构函数是编译器自动生成即可使用的,但有些编译器自动生成的析构函数却不能使用。

就像我们上面实现的日期类,调用系统自动生成的析构函数即可完成清理工作,但下面这个例子就需要我们手动的编写析构函数来完成清理:

class Array { 
public :     
    Array (int size)    {          
        _ptr = (int *)malloc( size*sizeof (int));    
    }
     // 这里的析构函数需要完成清(shi)理(fang)工(kong)作(jian)。    
    ~Array (){          
        if (_ptr){              
            free(_ptr);              
            _ptr = 0;         
    }    
} 
private :     
    int* _ptr ; 
};

四、赋值运算符重载

  • 运算符重载

为了增强程序的可读性,C++支持运算符重载。

运算符重载特征:     
1. operator+ 合法的运算符 构成函数名(重载<运算符的函数名:operator< )。

2. 重载运算符以后,不能改变运算符的优先级/结合性/操作数个数。

5个C++不能重载的运算符:  .*    ::    sizeof    ?:    .

  • 赋值运算符重载

拷贝构造函数是创建的对象,使用一个已有对象来初始化这个准备创建的对象。

赋值运算符的重载是对一个已存在的对象进行拷贝赋值。
 

class Date { 
public :     
    Date()    
    {}
     
    // 拷贝构造函数     
    Date (const Date& d)         
    : _year(d._year)         
    , _month(d._month)         
    , _day(d._day)    
    {}
    
     // 赋值操作符的重载     
    Date& operator = (const Date& d){           
         if (this != &d){              
            this->_year = d. _year;              
            this->_month = d. _month;              
            this->_day = d. _day;         
        }
         return *this ;    
    } 
private:     
    int _year ;     
    int _month ;     
    int _day ; 
};

void Test () {     
    Date d1 ;     
    Date d2 = d1; // 调用拷贝构造函数
     Date d3 ;     
    d3 = d1 ;    // 调用赋值运算符的重载 
}

猜你喜欢

转载自blog.csdn.net/cecilia3333/article/details/81176346