近万字的超详细C++类和对象，快进来看看吧-Toy模板网

这篇具有很好参考价值的文章主要介绍了近万字的超详细C++类和对象，快进来看看吧。希望对大家有所帮助。如果存在错误或未考虑完全的地方，请大家不吝赐教，您也可以点击"举报违法"按钮提交疑问。

前情提要：
http://t.csdn.cn/Kqf6D

1.类的6个默认成员函数

1.1构造函数

1.1.1 特性:

其特征如下：

1.1.2 初始化列表

注意：

1.1.3 explicit关键字

举例：

1.2析构函数

1.2.1 特性 :

析构函数是特殊的成员函数，

1.3 拷贝构造函数

1.3.1概念：

1.3.2特征：拷贝构造函数也是特殊的成员函数

1.3.3特性如下：

1.4赋值运算符重载

1.4.1运算符重载的概念

1.4.2 赋值运算符重载：

1. 赋值运算符重载格式

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

3. 用户没有显式实现时

1.4.3前置++和后置++重载

1.5 const成员

编辑

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

2.初始化列表

3. static成员

3.1 概念：

3.2 特性

问题：

4. 友元

4.1 友元函数

友元函数的说明

4.2 友元类

注意：

代码示例：

5. 内部类

特性：

6.拷贝对象时的一些编译器优化

6.1对象返回的总结

6.2函数传参的总结

7.匿名对象

1.类的6个默认成员函数

如果一个类中什么成员都没有，简称为空类。任何类在什么都不写时，编译器会自动生成以下6个默认成员函数。

默认成员函数：用户没有显式实现，编译器会生成的成员函数称为默认成员函数。

近万字的超详细C++类和对象，快进来看看吧

1.1构造函数

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

1.1.1 特性:

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

其特征如下：

1. 函数名与类名相同。

2. 无返回值。

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

4. 构造函数可以重载。

class Date
 {
  public:
      // 1.无参构造函数
      Date()
     {}
  
      // 2.带参构造函数
      Date(int year, int month, int day)
     {
          _year = year;
5. 如果类中没有显式定义构造函数，则C++编译器会自动生成一个无参的默认构造函数，一旦
用户显式定义编译器将不再生成。
          _month = month;
          _day = day;
     }
  private:
      int _year;
      int _month;
      int _day;
 };
  
  void TestDate()
 {
      Date d1; // 调用无参构造函数
      Date d2(2015, 1, 1); // 调用带参的构造函数
  
      // 注意：如果通过无参构造函数创建对象时，对象后面不用跟括号，否则编译器无法分析清楚函数声明还是调用
      // 以下代码的函数：声明了d3函数，该函数无参，返回一个日期类型的对象
      // warning C4930: “Date d3(void)”: 未调用原型函数(是否是有意用变量定义的?)
      Date d3();
}

// 注意：如果通过无参构造函数创建对象时，对象后面不用跟括号，否则编译器无法分析清楚是函数声明还是函数调用
// 以下代码的函数：声明了d3函数，该函数无参，返回一个日期类型的对象
// warning C4930: “Date d3(void)”: 未调用原型函数(是否是有意用变量定义的?)
Date d3();

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

6. 无参的构造函数和全缺省的构造函数都称为默认构造函数，并且默认构造函数只能有一个。

注意：无参构造函数、全缺省构造函数、我们没写编译器默认生成的构造函数，都可以认为是默认构造函数。

7.编译器生成的默认构造函数并没有什么用？

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

1.1.2 初始化列表

在创建对象时，编译器通过调用构造函数，给对象中各个成员变量一个合适的初始值。也就是虽然构造函数调用之后，对象中已经有了一个初始值，但是不能将其称为对对象中成员变量的初始化，构造函数体中的语句只能将其称为赋初值，而不能称作初始化。因为初始化只能初始化一次，而构造函数体内可以多次赋值。

初始化列表：以一个冒号开始，接着是一个以逗号分隔的数据成员列表，每个"成员变量"后面跟一个放在括号中的初始值或表达式。

注意：

1. 每个成员变量在初始化列表中只能出现一次(初始化只能初始化一次)

2. 类中包含以下成员，必须放在初始化列表位置进行初始化：

引用成员变量

const成员变量

自定义类型成员(且该类没有默认构造函数时)

3. 尽量使用初始化列表初始化，因为不管你是否使用初始化列表，对于自定义类型成员变量，一定会先使用初始化列表初始化。

4. 成员变量在类中声明次序就是其在初始化列表中的初始化顺序，与其在初始化列表中的先后次序无关

1.1.3 explicit关键字

构造函数不仅可以构造与初始化对象，对于单个参数或者除第一个参数无缺省值其余均有缺省值的构造函数，还具有类型转换的作用。

用explicit修饰构造函数，将会禁止构造函数的隐式转换。

举例：

 // 1. 单参构造函数，没有使用explicit修饰，具有类型转换作用
 // explicit修饰构造函数，禁止类型转换---explicit去掉之后，代码可以通过编译
class Date {
public:
	//explicit Date(int year)
	//	:_year(year)
	//{}
	
	// 2. 虽然有多个参数，但是创建对象时后两个参数可以不传递，没有使用explicit修饰，具
	//有类型转换作用
	//  explicit修饰构造函数，禁止类型转换
	 explicit Date(int year, int month = 1, int day = 1)
	 : _year(year)
	 , _month(month)
	 , _day(day)
	 {}
	 
	Date& operator=(const Date& d)
	{
		if (this != &d)
		{
			_year = d._year;
			_month = d._month;
			_day = d._day;
		}
		return *this;
	}
private:
	int _year;
	int _month;
	int _day;
};

void Test()
{
	Date d1(2022);
	Date d2(2023);
	Date d3(d2);
	// 用一个整形变量给日期类型对象赋值
	// 实际编译器背后会用2023构造一个无名对象，最后用无名对象给d1对象进行赋值
	d1 = 2023;
	// 将1屏蔽掉，2放开时则编译失败，因为explicit修饰构造函数，禁止了单参构造函数类型转换的作用
}

int main()
{
	Test();
}

1.2析构函数

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

1.2.1 特性 :

析构函数是特殊的成员函数，

1.2.2其特征如下：

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

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

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

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

内置类型成员：销毁时不需要资源清理，最后系统直接将其内存回收即可；

自定义类型而：若一个类的对象内部也有对象，要将其内部包含的类的对象销毁，所以要调用这个类对应的析构函数。

6. 如果类中没有申请资源时，析构函数可以不写，直接使用编译器生成的默认析构函数，比如 Date类；有资源申请时，一定要写，否则会造成资源泄漏，比如Stack类。

1.3 拷贝构造函数

1.3.1概念：

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

1.3.2特征：拷贝构造函数也是特殊的成员函数

1.3.3特性如下：

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

2. 拷贝构造函数的参数只有一个且必须是类类型对象的引用，使用传值方式编译器直接报错，因为会引发无穷递归调用。

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

#include<stdlib.h>
#include<iostream>

class Date
{
private:
    // 基本类型(内置类型)
    int _year = 2023;
    int _month = 4;
    int _day = 4;
    // 自定义类型
    Time _t;
};
class Time
{
public:
    Time()
    {
        _hour = 1;
        _minute = 1;
        _second = 1;
        //    注意：在编译器生成的默认拷贝构造函数中，内置类型是按照字节方式直接拷贝的，而自定
        //    义类型是调用其拷贝构造函数完成拷贝的。
    }
    Time(const Time& t)
    {
        _hour = t._hour+1;
        _minute = t._minute+1;
        _second = t._second+1;
        std::cout << "Time::Time(const Time&)" << std::endl;
    }
private:
    int _hour;
    int _minute;
    int _second;
};

int main()
{
    Date d1;//构造函数

    // 用已经存在的d1拷贝构造d2，此处会调用Date类的拷贝构造函数
    // 但Date类并没有显式定义拷贝构造函数，则编译器会给Date类生成一个默认的拷贝构造函数
        Date d2(d1);
    return 0;
}

其实此处Time生成的默认拷贝构造函数也是能使用的

class Time
{
public:
    Time()
    {
        _hour = 1;
        _minute = 1;
        _second = 1;
    }
    //Time(const Time& t)
    //{
    //    _hour = t._hour+1;
    //    _minute = t._minute+1;
    //    _second = t._second+1;
    //    std::cout << "Time::Time(const Time&)" << std::endl;
    //}
private:
    int _hour;
    int _minute;
    int _second;
};
class Date
{
private:
    // 基本类型(内置类型)
    int _year = 2023;
    int _month = 4;
    int _day = 4;
    // 自定义类型
    Time _t;
};
int main()
{
    Date d1;//构造函数

    // 用已经存在的d1拷贝构造d2，此处会调用Date类的拷贝构造函数
    // 但Date类并没有显式定义拷贝构造函数，则编译器会给Date类生成一个默认的拷贝构造函数
        Date d2(d1);
    return 0;
}

4.类中如果没有涉及资源申请时，拷贝构造函数是否写都可以；一旦涉及到资源申请时，则拷贝构造函数是一定要写的，否则就是浅拷贝。

近万字的超详细C++类和对象，快进来看看吧

5. 拷贝构造函数典型调用场景：

1.使用已存在对象创建新对象

2.函数参数类型为类类型对象

3.函数返回值类型为类类型对象

近万字的超详细C++类和对象，快进来看看吧

1.4赋值运算符重载

1.4.1运算符重载的概念

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

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

运算符重载成全局函数，注意重载成全局函数时没有this指针了，需要给两个参数。

bool operator==(const Date& d1, const Date& d2)
{
    return d1._year == d2._year
   && d1._month == d2._month
        && d1._day == d2._day;
}

但是这是全局的operator==，如何保证其封装性呢？

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;
};

注意：

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

2.重载操作符必须有一个类类型参数用于内置类型的运算符，其含义不能改变。

例如：内置的整型+，不能改变其含义作为类成员函数重载时，其形参看起来比操作数数目少1，因为成员函数的第一个参数为隐藏的this .* :: sizeof ?: . 注意以上5个运算符不能重载。

1.4.2 赋值运算符重载：

1. 赋值运算符重载格式

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

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

检测是否自己给自己赋值：*this！=d1；

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

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

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

3. 用户没有显式实现时

编译器会生成一个默认赋值运算符重载，以值的方式逐字节拷贝。

注意：

1.内置类型成员变量是直接赋值的，而自定义类型成员变量需要调用对应类的赋值运算符重载完成赋值。

2.如果类中未涉及到资源管理，赋值运算符是否实现都可以；一旦涉及到资源管理则必须要实现。

近万字的超详细C++类和对象，快进来看看吧

1.4.3前置++和后置++重载

1. 前置++：返回+1之后的结果
注意：this指向的对象函数结束后不会销毁，故以引用方式返回提高效率


 Date& operator++()
 {
 _day += 1;
 return *this;
 }

2.后置++

前置++和后置++都是一元运算符，为了让前置++与后置++形成能正确重载

C++规定：后置++重载时多增加一个int类型的参数，但调用函数时该参数不用传递，编译器
自动传递
注意：后置++是先使用后+1，因此需要返回+1之前的旧值，故需在实现时需要先将this保存
一份，然后给this+1
而temp是临时对象，因此只能以值的方式返回，不能返回引用


 Date operator++(int)
 {
 Date temp(*this);
 _day += 1;
 return temp;
 }

1.5 const成员

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

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

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

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

 Date* operator&()
 {
 return this ;
 }
 const Date* operator&()const
 {
 return this ;
 }

2.初始化列表

初始化列表：以一个冒号开始，接着是一个以逗号分隔的数据成员列表，每个"成员变量"后面跟一个放在括号中的初始值或表达式。

Date(int year, int month, int day)

     : _year(2023)
     , _month(4)
     , _day(4)
 {}

注意：

1. 每个成员变量在初始化列表中只能出现一次(初始化只能初始化一次)

2. 类中包含以下成员，必须放在初始化列表位置进行初始化：

引用成员变量 const成员变量自定义类型成员(且该类没有默认构造函数时)

3.尽量使用初始化列表初始化，因为不管你是否使用初始化列表，对于自定义类型成员变量，一定会先使用初始化列表初始化。

4. 成员变量在类中声明次序就是其在初始化列表中的初始化顺序，与其在初始化列表中的先后次序无关

2.1 explicit关键字

构造函数不仅可以构造与初始化对象，对于单个参数或者除第一个参数无默认值其余均有默认值的构造函数，还具有类型转换的作用。

以下是C++11规定的多参数构造函数的隐式类型转换的举例

单参构造函数同理

using namespace std;

class A {
public:
	A(int a, int b,int c)
		: _year ( a),
	      _month (b),
	      _day (c)
	{

	}
	A(const A& a)
	{
		cout << "const A& " << endl;
	}
private:
	int _year;
	int _month;
	int _day;
};
int main()
{
	A a = {1,2,3};
}

1. 单参/多参构造函数，没有使用explicit修饰，具有类型转换作用

explicit修饰构造函数，禁止类型转换

3. static成员

3.1 概念：

声明为static的类成员称为类的静态成员，用static修饰的成员变量，称之为静态成员变量；用 static修饰的成员函数，称之为静态成员函数。静态成员变量一定要在类外进行初始化面试题：实现一个类，计算程序中创建出了多少个类对象。

3.2 特性

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

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

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

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

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

问题：

1. 静态成员函数可以调用非静态成员函数吗？不可以

2. 非静态成员函数可以调用类的静态成员函数吗？可以

例题：求1+2+3+...+n，要求不能使用乘除法、for、while、if、else、switch、case等关键字及条件判断语句（A?B:C）。

使用静态成员变量


using namespace std;


class Sum
	{
	public:
		Sum()
		{
			_sum += _n;
			++_n;
		}
	
		static int GetSum()
		{
			return _sum;
		}
	private:
		static int _n;
		static int _sum;
	};
	
	class Solution {
	public:
		int Sum_Solution(int n) {
			Sum* p = new Sum[n];
			return Sum::GetSum();
		}
		~Solution()
		{
			cout << "~Solution()" << endl;
		}
	};
	int Sum::_n = 1;
	int Sum::_sum = 0;
	int main()
	{
		cout << Solution().Sum_Solution(100) << endl;
	}

不使用静态成员变量

class Solution {
public:
    int Sum_Solution(int n) {
        //通过与运算判断n是否为正数，以结束递归
        n && (n += Sum_Solution(n - 1));
        return n;
    }
};

4. 友元

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

4.1 友元函数

近万字的超详细C++类和对象，快进来看看吧

class Date
{
public:
Date(int year, int month, int day)
     : _year(year)
     , _month(month)
     , _day(day)
 {}
// d1 << cout; -> d1.operator<<(&d1, cout); 不符合常规调用
// 因为成员函数第一个参数一定是隐藏的this，所以d1必须放在<<的左侧
ostream& operator<<(ostream& _cout)
 {
     _cout << _year << "-" << _month << "-" << _day << endl;
     return _cout;
 }
private:
int _year;
int _month;
int _day;
};

友元函数可以直接访问类的私有成员，它是定义在类外部的普通函数，不属于任何类，但需要在类的内部声明，声明时需要加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修饰

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

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

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

4.2 友元类

友元类的所有成员函数都可以是另一个类的友元函数，都可以访问另一个类中的非公有成员。

注意：

友元关系是单向的，不具有交换性。

比如下面代码示例中的Time类和Date类，在Time类中声明Date类为其友元类，那么可以在Date类中直接访问Time类的私有成员变量，但想在Time类中访问Date类中私有的成员变量则不行。

友元关系不能传递如果C是B的友元， B是A的友元，则不能说明C时A的友元。

友元关系不能继承，在继承位置再给大家详细介绍。

代码示例：

class Time
{
	friend class Date;   // 声明日期类为时间类的友元类，则在日期类中就直接访问Time类中的私有成员变量
public:
	Time(int hour = 0, int minute = 0, int second = 0)
		: _hour(hour)
		, _minute(minute)
		, _second(second)
	{}

private:
	int _hour;
	int _minute;
	int _second;
};
class Date
{
public:
	Date(int year = 1900, int month = 1, int day = 1)
		: _year(year)
		, _month(month)
		, _day(day)
	{}

	void SetTimeOfDate(int hour, int minute, int second)
	{
		// 直接访问时间类私有的成员变量
		_t._hour = hour;
		_t._minute = minute;
		_t._second = second;
	}

private:
	int _year;
	int _month;
	int _day;
		Time _t;
};

5. 内部类

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

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

特性：

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

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

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

对上面例题进行内部类封装

class Solution {

  public:

    class Sum {
      public:
        Sum() {
            _sum += _n;
            ++_n;
        }

        static int GetSum() {
            return _sum;
        }

    };
    int Sum_Solution(int n) {
        Sum* p = new Sum[n];
        return Sum::GetSum();
    }
    ~Solution() {
        cout << "~Solution()" << endl;
    }
  private:
    static int _n;
    static int _sum;
};
int Solution::_n = 1;
int Solution::_sum = 0;

6.拷贝对象时的一些编译器优化

在传参和传返回值的过程中，一般编译器会做一些优化，减少对象的拷贝，这个在一些场景下还是非常有用的。

6.1对象返回的总结

1.接受返回值的对象，尽量使用拷贝构造方式接收，不要赋值接收。

2.函数中返回对象时尽量返回匿名对象。

6.2函数传参的总结

尽量使用const &传参。

7.匿名对象

但是我们可以这么定义匿名对象，匿名对象的特点不用取名字，但是他的生命周期只有这一行文章来源地址https://www.toymoban.com/news/detail-407903.html

		cout << Solution().Sum_Solution(100) << endl;

到了这里，关于近万字的超详细C++类和对象，快进来看看吧的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！

近万字的超详细C++类和对象，快进来看看吧

1.类的6个默认成员函数

1.1构造函数

1.1.1 特性:

其特征如下：

1.1.2 初始化列表

注意：

1.1.3 explicit关键字

举例：

1.2析构函数

1.2.1 特性 :

析构函数是特殊的成员函数，

1.3 拷贝构造函数

1.3.1概念：

1.3.2特征： 拷贝构造函数也是特殊的成员函数

1.3.3特性如下：

1.4赋值运算符重载

1.4.1运算符重载的概念

1.4.2 赋值运算符重载：

1. 赋值运算符重载格式

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

3. 用户没有显式实现时

1.4.3前置++和后置++重载

1.5 const成员

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

2.初始化列表

3. static成员

3.1 概念：

3.2 特性

问题：

4. 友元

4.1 友元函数

友元函数的说明

4.2 友元类

注意：

代码示例：

5. 内部类

特性：

6.拷贝对象时的一些编译器优化

6.1对象返回的总结

6.2函数传参的总结

7.匿名对象

相关文章

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

微信扫一扫打赏

支付宝扫一扫领取红包，优惠每天领

二维码1

二维码2

1.3.2特征：拷贝构造函数也是特殊的成员函数