C++之旅----类和对象（下）

文章目录

• 目录

  一、类的默认成员函数

  1.构造函数

• 2.析构函数

  3.拷贝构造函数

   4.赋值运算符重载

  5.const成员和取地址重载

  二.static成员

  三.友元

  1. 友元函数

  2.友元类

  3.内部类

  总结

  ---

---

一、类的默认成员函数

如果一个类中什么成员都没有，简称为空类。空类中真的什么都没有吗？并不是，任何类在什么都不写时，编译器会自动生成以下6 个默认成员函数。 默认成员函数：用户没有显式实现，编译器会生成的成员函数称为默认成员函数。

1.构造函数

构造函数 是一个 特殊的成员函数，名字与类名相同 , 创建类类型对象时由编译器自动调用 ，以保证每个数据成员都有 一个合适的初始值，并且在对象整个生命周期内只调用一次 。

构造函数 是特殊的成员函数，需要注意的是，构造函数虽然名称叫构造，但是构造函数的主要任务并不是开空间创建对象，而是初始化对象 。构造函数具有以下几种特性：

1. 函数名与类名相同。

2. 无返回值。

3. 对象实例化时编译器 自动调用 对应的构造函数。

4. 构造函数可以重载。

  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 TestDate ()

{

      Date d1 ; // 调用无参构造函数

      Date d2 ( 2015 , 1 , 1 ); // 调用带参的构造函数

      // 注意：如果通过无参构造函数创建对象时，对象后面不用跟括号，否则就成了函数声明

      // 以下代码的函数：声明了 d3 函数，该函数无参，返回一个日期类型的对象

      Date d3 ();

}

5. 如果类中没有显式定义构造函数，则 C++ 编译器会自动生成一个无参的默认构造函数，一旦用户显式定义编译器将不再生成。

  class Date

{

  public :

/*

// 如果用户显式定义了构造函数，编译器将不再生成

Date(int year, int month, int day)

{

_year = year;

_month = month;

_day = day;

}

*/

void Print ()

{

cout << _year << "-" << _month << "-" << _day << endl ;

}

  private :

int _year ;

int _month ;

int _day ;

};

  int main ()

{

// 将 Date 类中构造函数屏蔽后，代码可以通过编译，因为编译器生成了一个无参的默认构造函数

// 将 Date 类中构造函数放开，代码编译失败，因为一旦显式定义任何构造函数，编译器将不再

生成

// 无参构造函数，放开后报错： error C2512: “Date”: 没有合适的默认构造函数可用

Date d1 ;

return 0 ;

}

默认构造函数的作用

  关于编译器生成的默认成员函数，很多人肯定会有疑惑：不实现构造函数的情况下，编译器会生成默认的构造函数。但是看起来默认构造函数又没什么用？ 对象调用了编译器生成的默认构造函数，但是对象 _year/_month/_day ，依旧是随机值。也就说在这里 编译器生成的 默认构造函数并没有什么用？？

解答：C++ 把类型分成内置类型 ( 基本类型 ) 和自定义类型。内置类型就是语言提供的数据类 型，如：int/char... ，自定义类型就是我们使用 class/struct/union 等自己定义的类型，看看下面的程序，就会发现编译器生成默认的构造函数会对自定类型成员_t 调用的它的默认成员函数。

class Time

{

public :

Time ()

{

cout << "Time()" << endl ;

_hour = 0 ;

_minute = 0 ;

_second = 0 ;

}

private :

int _hour ;

int _minute ;

int _second ;

};

class Date

{

private :

// 基本类型 ( 内置类型 )

int _year = 1970;

int _month = 1;

int _day = 1;

// 自定义类型

Time _t ;

};

int main ()

{

Date d ;

return 0 ;

}

注意： C++11 中针对内置类型成员不初始化的缺陷，又打了补丁，即： 内置类型成员变量在 类中声明时可以给默认值 。

2.析构函数

析构函数：与构造函数功能相反，析构函数不是完成对对象本身的销毁，局部对象销毁工作是由编译器完成的。而对象在销毁时会自动调用析构函数，完成对象中资源的清理工作 。

析构函数 是特殊的成员函数，其 特征 如下：

1. 析构函数名是在类名前加上字符 ~ 。

2. 无参数无返回值类型。

3. 一个类只能有一个析构函数。若未显式定义，系统会自动生成默认的析构函数。注意：析构

函数不能重载

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

5.编译器会生成的默认析构函数，自定义类型成员不能自动生成默认构造函数，要调用它的析构函数时，需要我们显示写出它的析构函数。

3.拷贝构造函数

拷贝构造函数 ： 只有单个形参 ，该形参是对本 类类型对象的引用 ( 一般常用 const 修饰 ) ，在用 已存 在的类类型对象创建新对象时由编译器自动调用 。

拷贝构造函数也是特殊的成员函数，其 特征 如下：

1. 拷贝构造函数 是构造函数的一个重载形式 。

2. 拷贝构造函数的 参数只有一个 且 必须是类类型对象的引用 ，使用 传值方式编译器直接报错 ，

因为会引发无穷递归调用。

class Date

{

public :

Date ( int year = 1900 , int month = 1 , int day = 1 )

{

_year = year ;

_month = month ;

_day = day ;

}

// Date(const Date& d)   // 正确写法

    Date ( const Date & d )   // 错误写法：编译报错，会引发无穷递归

{

_year = d . _year ;

_month = d . _month ;

_day = d . _day ;

}

private :

int _year ;

int _month ;

int _day ;

};

int main ()

{

Date d1 ;

Date d2 ( d1 );

return 0 ;

}

3. 若未显式定义，编译器会生成默认的拷贝构造函数。 默认的拷贝构造函数对象按内存存储按字节序完成拷贝，这种拷贝叫做浅拷贝，或者值拷贝。

注意：在编译器生成的默认拷贝构造函数中，内置类型是按照字节方式直接拷贝的，而自定

义类型是调用其拷贝构造函数完成拷贝的。

 4.赋值运算符重载

C++ 为了增强代码的可读性引入了运算符重载 ， 运算符重载是具有特殊函数名的函数 ，也具有其返回值类型，函数名字以及参数列表，其返回值类型与参数列表与普通的函数类似。

函数名字为：关键字 operator 后面接需要重载的运算符符号 。

函数原型： 返回值类型  operator 操作符 ( 参数列表 )

注意：

不能通过连接其他符号来创建新的操作符：比如 operator@

重载操作符必须有一个类类型参数

用于内置类型的运算符，其含义不能改变，例如：内置的整型 + ，不 能改变其含义

作为类成员函数重载时，其形参看起来比操作数数目少 1 ，因为成员函数的第一个参数为隐藏的this

.*   ::   sizeof   ?  :  . 注意以上5 个运算符不能重载。

class Date

{

public :

Date ( int year = 1900 , int month = 1 , int day = 1 )

{

        _year = year ;

        _month = month ;

        _day = day ;

  }

   

    // bool operator==(Date* this, const Date& d2)

    // 这里需要注意的是，左操作数是 this ，指向调用函数的对象

    bool operator == ( const Date & d2 )

{

        return _year == d2 . _year ;

            && _month == d2 . _month

            && _day == d2 . _day ;

}

private :

int _year ;

int _month ;

int _day ;

};

4.1赋值运算符重载

1.   赋值运算符重载格式

参数类型 ： const T& ，传递引用可以提高传参效率

返回值类型 ： T& ，返回引用可以提高返回的效率，有返回值目的是为了支持连续赋值

检测是否自己给自己赋值

返回 *this ：要复合连续赋值的含义

2. 赋值运算符只能重载成类的成员函数不能重载成全局函数

原因：赋值运算符如果不显式实现，编译器会生成一个默认的。此时用户再在类外自己实现一个全局的赋值运算符重载，就和编译器在类中生成的默认赋值运算符重载冲突了，故赋值

运算符重载只能是类的成员函数。

3. 用户没有显式实现时，编译器会生成一个默认赋值运算符重载，以值的方式逐字节拷贝 。注意：内置类型成员变量是直接赋值的，而自定义类型成员变量需要调用对应类的赋值运算符

重载完成赋值。

5.const成员和取地址重载

const

将 const 修饰的 “ 成员函数 ” 称之为 const 成员函数 ， const 修饰类成员函数，实际修饰该成员函数 隐含的 this 指针 ，表明在该成员函数中 不能对类的任何成员进行修改。

5.1取地址及const取地址操作符重载

这两个默认成员函数一般不用重新定义 ，编译器默认会生成。

class Date

{

public :

Date * operator & ()

{

return this ;

比特就业课 }

const Date * operator & () const

{

return this ;

}

private :

int _year ; // 年

int _month ; // 月

int _day ; // 日

};

这两个运算符一般不需要重载，使用编译器生成的默认取地址的重载即可，只有特殊情况，才需要重载，比如想让别人获取到指定的内容.

二.static成员

声明为 static 的类成员 称为 类的静态成员 ，用 static 修饰的 成员变量 ，称之为 静态成员变量 ；用 static 修饰 的 成员函数 ，称之为 静态成员函数 。 静态成员变量一定要在类外进行初始化。

特性

1. 静态成员 为 所有类对象所共享 ，不属于某个具体的对象，存放在静态区

2. 静态成员变量 必须在 类外定义 ，定义时不添加 static 关键字，类中只是声明

3. 类静态成员即可用 类名 :: 静态成员 或者 对象 . 静态成员 来访问

4. 静态成员函数 没有 隐藏的 this 指针 ，不能访问任何非静态成员

5. 静态成员也是类的成员，受 public 、 protected 、 private 访问限定符的限制

三.友元

友元提供了一种突破封装的方式，有时提供了便利。但是友元会增加耦合度，破坏了封装，所以 友元不宜多用。

友元分为： 友元函数 和 友元类

1. 友元函数

问题：现在尝试去重载 operator<< ，然后发现没办法将 operator<< 重载成成员函数。 因为 cout 的 输出流对象和隐含的 this 指针在抢占第一个参数的位置 。 this 指针默认是第一个参数也就是左操作

数了。但是实际使用中 cout 需要是第一个形参对象，才能正常使用。所以要将 operator<< 重载成全局函数。但又会导致类外没办法访问成员，此时就需要友元来解决。operator>> 同理。

友元函数 可以 直接访问 类的 私有 成员，它是 定义在类外部 的 普通函数 ，不属于任何类，但需要在类的内部声明，声明时需要加friend 关键字。

class Date

{

friend ostream& operator<<(ostream& _cout, const Date& d);

friend istream& operator>>(istream& _cin, Date& d);

public :

Date ( int year = 1900 , int month = 1 , int day = 1 )

: _year ( year )

, _month ( month )

, _day ( day )

{}

private :

int _year ;

int _month ;

int _day ;

};

ostream & operator << ( ostream & _cout , const Date & d )

{

_cout << d . _year << "-" << d . _month << "-" << d . _day ;

return _cout ;

}

istream & operator >> ( istream & _cin , Date & d )

{

_cin >> d . _year ;

_cin >> d . _month ;

_cin >> d . _day ;

return _cin ;

}

int main ()

{

Date d ;

cin >> d ;

cout << d << endl ;

return 0 ;

}

注意：

友元函数 可访问类的私有和保护成员，但 不是类的成员函数

友元函数 不能用 const 修饰

友元函数 可以在类定义的任何地方声明， 不受类访问限定符限制

一个函数可以是多个类的友元函数

友元函数的调用与普通函数的调用原理相同

2.友元类

友元类的所有成员函数都可以是另一个类的友元函数，都可以访问另一个类中的非公有成员。 友元关系是单向的，不具有交换性。 友元关系不能传递 如果C 是 B 的友元， B 是 A 的友元，则不能说明 C时A的友元。友元关系不能继承 

3.内部类

概念： 如果一个类定义在另一个类的内部，这个内部类就叫做内部类 。内部类是一个独立的类， 它不属于外部类，更不能通过外部类的对象去访问内部类的成员。外部类对内部类没有任何优越

的访问权限。

注意： 内部类就是外部类的友元类 ，参见友元类的定义，内部类可以通过外部类的对象参数来访问外部类中的所有成员。但是外部类不是内部类的友元。

特性：

1. 内部类可以定义在外部类的 public 、 protected 、 private 都是可以的。

2. 注意内部类可以直接访问外部类中的 static 成员，不需要外部类的对象 / 类名。

3. sizeof( 外部类 )= 外部类，和内部类没有任何关系。

class A

{

private :

static int k ;

int h ;

public :

class B // B 天生就是 A 的友元

{

public :

void foo ( const A & a )

{

cout << k << endl ; //OK

cout << a . h << endl ; //OK

}

};

};

int A::k = 1 ;

int main ()

{

    A::B b ;

    b . foo ( A ());

   

    return 0 ;

}

---

总结

再次理解类和对象

现实生活中的实体计算机并不认识，计算机只认识二进制格式的数据。如果想要让计算机认识现 实生活中的实体，用户必须通过某种面向对象的语言，对实体进行描述，然后通过编写程序，创

建对象后计算机才可以认识。比如想要让计算机认识洗衣机，就需要：

1. 用户先要对现实中洗衣机实体进行抽象 --- 即在人为思想层面对洗衣机进行认识，洗衣机有什 么属性，有那些功能，即对洗衣机进行抽象认知的一个过程

2. 经过 1 之后，在人的头脑中已经对洗衣机有了一个清醒的认识，只不过此时计算机还不清楚，想要让计算机识别人想象中的洗衣机，就需要人通过某种面相对象的语言( 比如： C++ 、 Java、 Python 等 ) 将洗衣机用类来进行描述，并输入到计算机中。

3. 经过 2 之后，在计算机中就有了一个洗衣机类，但是洗衣机类只是站在计算机的角度对洗衣机对象进行描述的，通过洗衣机类，可以实例化出一个个具体的洗衣机对象，此时计算机才

能洗衣机是什么东西。

4. 用户就可以借助计算机中洗衣机对象，来模拟现实中的洗衣机实体了。在类和对象阶段，大家一定要体会到，类是对某一类实体 ( 对象 ) 来进行描述的，描述该对象具有那 些属性，那些方法，描述完成后就形成了一种新的自定义类型，才用该自定义类型就可以实例化 具体的对象 。