C++ ---- 类和对象（中）

已于 2023-05-13 15:06:28 修改
阅读量597 收藏 6
点赞数 5
文章标签： c++
于 2023-05-13 11:14:09 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_59351791/article/details/130609978
版权

目录

类的默认成员函数介绍

构造函数

构造函数概念

构造函数特性

析构函数

析构函数概念

析构函数特性

拷贝构造

拷贝构造概念

拷贝构造特点

赋值重载

赋值重载介绍

赋值重载特性

取地址重载和const取地址重载

const成员

 取地址和const取地址重载

类的默认成员函数介绍

当我们定义一个空类时，类中并非什么都没有，编译器会自动生成6个成员函数，这6个用户不显示实现，编译器会自动生成的函数称为默认成员函数。

//什么也没定义的空类
//用户没有显示定义，编译器自动生成6个默认成员函数
class zxy
{
	//构造函数

	//拷贝构造

	//赋值重载
	
	//析构函数

	//取地址重载

	//const 取地址重载
};

●构造函数：主要完成初始化工作。

●析构函数：对资源进行清理。

●拷贝构造函数：用同类型对象创建对象。

●赋值重载：把一个对象赋值给另一个对象。

●取地址重载：对普通对象取地址。

●const取地址重载：对const对象取地址。

构造函数

构造函数概念

构造函数是特殊的成员函数，创建类类型对象时由编译器自动调用，在该对象生命周期内只调用一次！---- 构造函数的任务并不是开空间创建对象，而是初始化对象。

对比以往的初始化操作（以日期为例）：

class Date
{
public:
	void Init(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 d1;
	d1.Init(2001,10,3);

	return 0;
}

观察上述代码，Date类型的对象可以通过Init公有函数设置日期完成初始化，也就说每次创建对象都要调用Init方法。对比调用Init初始化的方式，构造函数的出现就是懒人的福音，它会在对象创建时自动调用，完成初始工作。下面会详细介绍构造函数的用法及特性！

构造函数特性

●函数名和类名相同，没有返回值。

●创建对象时，编译器自动调用构造函数。

●构造函数可以重载。

●不用传参就能调用的构造，叫做默认构造。如：无参构造，全缺省构造。

●若未显示定义构造函数，编译器会默认生成。显示定义，编译器则不在生成。

●默认生成的构造函数对内置类型（int/double/int*...）不做处理,对自定义类型调用其自身的默认构造。

●针对第7条，默认生成的构造函数不对内置类型做处理的情况，C++11中，可以将内置类型在类中声明时给缺省值，如：class zxy{int a = 10;}; 注意这不是初始化，而是给a一个缺省值。

●自定义类型作为其他类的成员变量时，要提供默认构造。

1.函数名和类名相同，没有返回值！

class Date
{
public:
	//构造函数名和类名相同
	Date()
	{}
private:
	int _year;
	int _month;
	int _day;
};

3.创建类类型对象时，编译器自动调用对应的构造函数。

class Date
{
public:
	//构造函数名和类名相同
	Date()
	{
		cout << "Date():调用构造函数" << endl;
	}
private:
	int _year;
	int _month;
	int _day;
};

int main()
{
	Date d1;
	return 0;
}

上图示例中并没有调用任何函数，只是创建了一个Date类型的对象d1,通过测试结果可以得知，当用自定义类型创建对象时，编译器会自动调用它的构造函数。

4.构造函数可以重载。

根据不同的需求可以提供多个构造函数，无参，带参，全缺省，半缺省等。编译器会自动匹配合适的构造函数调用。

class Date
{
public:
	//无参
	Date()
	{
		//...
	}
	//带参
    Date(int year,int month,int day)
	{
		_year = year;
		_month = month;
		_day = day;
	}
private:
	int _year;
	int _month;
	int _day;
};

int main()
{
	Date d1;
	Date d2(2001, 10, 3);
	return 0;
}

需要注意的是，当构造函数不需要传参的时候，不要在对象名的后面加（），会和函数声明混淆。

错误的写法：
Date d1();

还要注意的是，如果同时提供了无参和全缺省，可能存在调用不明确的问题：在下述代码中同时提供了无参构造和全缺省构造,创建对象:Date d1; 构造函数调用不明确！！

class Date
{
public:
	//无参
	Date()
	{
		//...
	}
	//带参
    Date(int year = 2001,int month = 10,int day = 3)
	{
		_year = year;
		_month = month;
		_day = day;
	}
private:
	int _year;
	int _month;
	int _day;
};

int main()
{
	Date d1;
	return 0;
}

5.若未显示定义构造函数，编译器会默认生成。显示定义，编译器则不在生成。

6.不用传参就能调用的构造，叫做默认构造。如：无参构造，全缺省构造，默认生成的构造。

7.默认生成的构造函数对内置类型（int/double/int*...）不做处理,对自定义类型调用其自身的默认构造。

class Time
{
public:
	Time()
	{
		cout << "Time()" << endl;
	}
private:
	int _hour;
	int _minute;
	int _second;
};

class Date
{
	//没有显示定义构造，默认生成
private:
	//内置类型
	int _year;
	int _month;
	int _day;
	//自定义类型
	Time _t;
};

int main()
{
	Date d1;
	return 0;
}

8.针对第7条，默认生成的构造函数不对内置类型做处理的情况，C++11中，可以将内置类型在类中声明时给缺省值，如：int a = 10; 注意这不是初始化，而是给a一个缺省值。

class Date
{
	//没有显示定义构造，默认生成
private:
	//内置类型
	int _year = 1;
	int _month = 1;
	int _day = 1;
	//自定义类型
	Time _t;
};

 9.自定义类型作为其他类的成员变量时，要提供默认构造。

class Time
{
public:
	Time(int hour)
	{
		cout << "Time()" << endl;
		_hour = 0;
		_minute = 0;
		_second = 0;
	}
private:
	int _hour;
	int _minute;
	int _second;
};

将Time类中的构造函数定义成上述代码中的样子，此时显示定义了构造函数，编译器不会默认生成。我们定义的又不是默认构造（默认构造的几种回看第6条）。报错：_t不具备合适的默认构造

析构函数

析构函数概念

析构函数的功能和构造函数相反。析构函数会在对象销毁时自动调用（对象销毁的工作是编译器完成的，如函数中的局部对象，出了函数作用域就销毁），完成对象中资源的清理工作！

析构函数特性

●析构函数名在类名前加上字符~，没有参数，没有返回值类型。

●一个类只能有一个析构函数，未显示定义会默认生成，显示定义则不在生成！析构函数不能重载。

●对象生命周期结束时，编译器自动调用析构函数。

●编译器自动生成的析构函数，会对自定义类型成员调用它的析构函数。

●内置类型成员，销毁时不用资源清理，最后由系统将内存回收即可。

●如果类中没有申请资源时，析构函数可以不写，如：Date类。当涉及资源的申请时，要显示的定义析构函数，避免内存泄露，如statck,queue。

●析构的顺序：先创建的对象后销毁，后创建的对象先销毁。

1.析构函数名在类名前加上字符~。没有参数，没有返回值类型。

~Stack(){}

2.一个类只能有一个析构函数，未显示定义会默认生成，显示定义则不在生成！析构函数不能重载

5.对象生命周期结束时，编译器自动调用析构函数。(以Stack为例)

class Stack
{
public:
	//构造函数
	Stack(size_t capacity = 10)
	{
		_array = (int*)malloc(sizeof(int) * capacity);
		if (_array == nullptr)
		{
			perror("malloc申请空间失败!!");
			exit(1);
		}
		_capacity = capacity;
		_size = 0;

		cout << "Stack()构造" << endl;
	}
	//析构函数
	~Stack()
	{
		free(_array);
		_size = 0;
		_capacity = 0;

		cout << "~stack()析构" << endl;
	}
private:
	int* _array;
	size_t _size;
	size_t _capacity;
};

int main()
{
	Stack s1;

	return 0;
}

6.编译器自动生成的析构函数，会对自定义类型成员调用它的析构函数。内置类型成员，销毁时不用资源清理，最后由系统将内存回收即可。

class Stack
{
public:
	Stack(size_t capacity = 10)
	{
		_array = (int*)malloc(sizeof(int)*capacity);
		if (_array == nullptr)
		{
			perror("malloc申请空间失败!!");
			exit(1);
		}
		_capacity = capacity;
		_size = 0;

		cout << "Stack()构造" << endl;
	}

	//析构，涉及资源清理，显示定义析构
	//析构的顺序和构造的顺序相反
	~Stack()
	{
		free(_array);
		_size = 0;
		_capacity = 0;

		cout << "~stack()析构" << endl;
	}
private:
	int* _array;
	size_t _size;
	size_t _capacity;
};

class MyQueue
{
	//没有显示定义构造函数，自定义类型调用其自身的默认构造

	//析构函数没有显示的定义，自定义类型调用其自身的析构函数
private:
	Stack s1;
	Stack s2;
};

int main()
{
	MyQueue my1;
	return 0;
}

 8.如果类中没有申请资源时，析构函数可以不写，如：Date类。当涉及资源的申请时，要显示的定义析构函数，避免内存泄露，如statck,queue。

拷贝构造

拷贝构造概念

用已存在的类类型对象创建新对象时，编译器自动调用拷贝构造函数。如：传值调用，传值返回。

拷贝构造特点

●拷贝构造是构造函数的重载。

●拷贝构造的参数必须为类类型的引用，且只有一个形参。

●拷贝构造如果使用传值的方式编译器会直接报错，因为会引发无穷递归，传值调用要发生拷贝，自定义类型对象调用自身的拷贝构造。

●拷贝构造若未显示定义，编译器会默认生成，默认生成的拷贝构造对内置类型按照字节拷贝，自定义类型去调用其自身的拷贝构造。（浅拷贝）

●在涉及资源的申请和释放场景中，拷贝构造需要显示的定义（要写析构，就要写拷贝构造）

1.拷贝构造是构造函数的重载。

拷贝构造函数名和类型相同，也没有返回值，参数为必须为类类型的引用，且只有一个形参，是构造函数的重载。

例：Stack (const Stack& st){}

加const的原因是为了防止在拷贝的过程中，将拷贝和被拷贝写反：如_A = st._A 写成 st._A = _A。

2.函数参数为类类型对象，形参是实参的一份临时拷贝，自动调用拷贝构造。

class Stack
{
public:
	//无参默认构造
	Stack()
	{
	}
	//拷贝构造
	Stack(const Stack& st)
	{
		cout << "拷贝构造调用" << endl;
	}
};

void Fun(Stack st)
{
	//...
}
int main()
{
	Stack st;
	Fun(st);
	return 0;
}

如上述代码，只是调用了Fun函数，该函数的参数类型是Stack类型的，在传值传参的过程中，发生了拷贝，自动调用该类类型的拷贝构造。

2.如果使用传值的方式编译器会直接报错，因为会引发无穷递归，传值调用要发生拷贝，自定义类型对象调用自身的拷贝构造，调用拷贝构造本身就要传参。所以拷贝构造的参数是类类型的引用。

 4.拷贝构造若未显示定义，编译器会默认生成，默认生成的拷贝构造对内置类型按照字节拷贝，自定义类型去调用其自身的拷贝构造。

class B
{
public:
	~B()
	{
		cout << "~B():调用析构" << endl;
	}
private:
	int _b;
};

class A
{
private:
	int _a1;
	int _a2;
	B _b1;
};

int main()
{
	A a;
	return 0;
}

A类没有显示的定义拷贝构造，编译器自动生成，自定义类型调用其自己的拷贝构造，内置类型逐自己拷贝。

 为了避免干扰，只打印了自定义类型调用析构的效果。

浅拷贝问题：

class Stack
{
public:
	//构造
	Stack(size_t capacity = 10)
	{
		_array = (int*)malloc(sizeof(int)*capacity);
		_size = 0;
		_capacity = capacity;
	}

	//没有显示定义拷贝构造，编译器默认生成
	//内置类型按字节拷贝
	
	//析构
	~Stack()
	{
		free(_array);
		_size = _capacity = 0;
	}
private:
	int* _array;
	size_t _size;
	size_t _capacity;
};

int main()
{
	Stack st1;
	Stack st2(st1);
	return 0;
}

 解决：显示的定义拷贝构造，改用深拷贝

	Stack(const Stack& st)
	{
		_array = (int*)malloc(sizeof(int)*st._capacity);
		memcpy(_array,st._array,sizeof(int)*st._capacity);

		_size = st._size;
		_capacity = st._capacity;

		cout << "深拷贝" << endl;
	}

 如上图所示，st2对st1进行了深拷贝，各自有独立的空间，插入数据互相也不会影响。

5.在涉及资源的申请和释放场景中，拷贝构造需要显示的定义（要写析构，就要写拷贝构造）。

6.拷贝构造的调用场景：

  • 使用已经存在的对象创建新对象。
class A
{
public:
	A() {}
	A(const A& a)
	{
		cout << "拷贝构造调用" << endl;
	}
};

int main()
{
	A a1;
	A a2(a1);
	return 0;
}

  • 函数参数为类类型对象，形参是实参的一份临时拷贝，自动调用拷贝构造。
void Fun(A a)
{
	//...
}

int main()
{
	A a1;
	Fun(a1);
	return 0;
}

  • 当函数返回值为类类型对象，传值返回的过程中要产生临时变量，先存在寄存器或者上层栈帧中，这个期间的拷贝调用拷贝构造。
A Fun()
{
	A aa;
	return aa;
}

int main()
{
	A a1;
	Fun();
	return 0;
}

赋值重载

赋值重载介绍

赋值重载的主要功能就是将一个对象赋值给另一个对象，注意和拷贝构造进行区分，拷贝构造是用一个已经存在的对象创建一个新对象，赋值重载是将一个对象赋值给另一已经存在的对象。谈到拷贝和赋值，有一个容易混淆的写法：

	A a1;
	A a2 = a1;
class A
{
public:
	A() {}
	A(const A& a)
	{
		cout << "拷贝构造" << endl;
	}
	A& operator=(const A& a)
	{
		cout << "赋值重载" << endl;
	}
};

int main()
{
	A a1;
	A a2 = a1;
	return 0;
}

 上述的写法实际上调用的是拷贝构造，本质上是用一个存在的对象创建另一个对象。

 接着回到正文，为了增加代码的可读性，C++引入了运算符重载，赋值重载就是运算符重载中的一种。运算符重载具有特殊的函数名（关键字operator关键字后面接需要重载的运算符号如：+、-）。

返回类型 operator操作符(){}

因为赋值重载是运算符重载的一种，所以先来谈论什么是运算符重载：以日期类为例，自定义类型的两个日期类对象，直接使用==、+、-这些运算符是不可以的：

class Date
{
public:
	Date(int year, int month, int day)
	{
		_year = year;
		_month = month;
		_day = day;
	}

	void Show()
	{
		cout << _year << "/" << _month << "/" << _day << endl;
	}

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

int main()
{
	Date d1(2001,10,3);
	Date d2(2001, 2, 9);

	d1 += d2;
	d1 -= d2;

	return 0;
}

 基于上述问题，我们可以在类中定义一个成员函数来判断两个日期的大小，或者实现其它功能

bool AddFun()
{
   //...日期加法的逻辑
}

在我们有需求时，调用成员函数即可，如：d1.AddFun(d2);  这样的写法和我们熟知的+、-、==、>等运算符比较，可读性更差一些！所以引入了运算符重载，在使用上和正常的+、-操作没什么不同，下面对部分运算符进行重载，观察运行效果：

class Date
{
public:
	Date(int year, int month, int day)
	{
		_year = year;
		_month = month;
		_day = day;
	}

	void Show()
	{
		cout << _year << "/" << _month << "/" << _day << endl;
	}
	//重载==
	bool operator==(const Date& d1)
	{
		cout << "调用重载的==" << endl;

		return _year == d1._year
			&& _month == d1._month
			&& _day == d1._day;
	}
	//重载!=
	bool operator!=(const Date& d1)
	{
		return !(*this == d1);
	}
	//重载>
	bool operator>(const Date& d1)
	{
		cout << "调用重载的>" << endl;
		if (_year > d1._year)
		{
			return true;
		}
		else if(_year == d1._year && _month > d1._month)
		{
			return true;
		}
		else if (_year == d1._year && _month == d1._month && _day > d1._day)
		{
			return true;
		}
		return false;
	}

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

int main()
{
	Date d1(2001,10,3);
	Date d2(2001, 2, 9);

	//d1>d2 等价 d1.operator>(d2)
	cout << (d1 > d2) << endl;
	//d1==d2 等价 d2.operator==(d2)
	cout << (d1 == d2) << endl;
	return 0;
}

运算符重载后，就可以按照正常的使用习惯进行操作，例如：d1 == d2,d1 > d2。但是它们的原型是d1.operator==(d2); d1.operator>(d2)。 运算符重载后，在使用上提供了便捷，在代码的可读性上更为直观。

关于运算符重载还有几点要谈：

1.不能通过operator关键字连接其他符号创建新的操作符，如：operator@。

2.重载操作符必须有一个类类型参数，也就是说不能随便重载，比如：int + int

int operator+(int a, int b)
{
	return a * 10 + b;
}

int main()
{
	int a = 10,b =5;
	int c = a + b;
	return 0;
}

3,作为类成员函数时，形参比操作数少1，因为成员函数的第一个参数为隐藏的this指针。

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

5.前置++/--和后置++/--。（相关细节参考日期类模拟实现的文章）。

对于自定义类型而言，后置++/--比前置++/--多了一次拷贝，在实现上后置的++/--的参数列表要显示的写int,这是和编译器的暗号，用来区分是前置++/--还是后置++/--。

T& operator++()
{
    //...
}

T operator++(int)
{   
    //...
}

还需要说明的是，前置++适合返回类类型的引用，减少一次拷贝。而后置++返回的是局部变量，只能传值返回。

6.流插入和流提取运算符重载。（相关细节参考日期类模拟实现的文章）。

流插入和流提取在基础篇介绍过，它们分别是istream和ostream的对象，对于自定义类型而言，流插入和流提取是无法识别的，因为库中只实现了内置类型的<<和>>重载。当我们想要自定义类型的对象像内置类型一样输出和输出时，需要重载<<和>>。

赋值重载特性

●赋值运算符重载：返回值类型  operator=(const T& )。

●参数类型const T& ，减少拷贝。返回值类型T&，支持连续赋值，d1 = d2 = d3。

●返回值返回*this，支持连续赋值。

●自己给自己赋值的情况要检查，如：d1 = d2。

●不显示定义编译器会自动生成，内置类型逐字节拷贝，自定义类型调用其自己的赋值重载。

●赋值运算符重载只能重载成类的成员函数，不能重载成全局函数。

●当有资源申请，没有显示定义赋值重载的情况，可能会出现内存泄露和重复析构。

1、赋值运算符重载单参数为const T& ，返回值为T&，支持连续赋值。（以Stack为例：）

class Stack
{
public:
	//赋值重载
	Stack& operator=(const Stack& s1)
	{
		//....
		return *this;
	}
private:
	int* _array;
	int _size;
	int _capacity;
}

2.不显示定义编译器会自动生成，内置类型逐字节拷贝，自定义类型调用其自己的赋值重载。

class A
{
public:
	A& operator=(const A& A)
	{
		_a1 = A._a1;
		_a2 = A._a2;
		cout << "A& operator=(const A& A)" << endl;
		return *this;
	}
private:
	int _a1=10;
	int _a2=20;
};

class B
{
	//没有显示的定义赋值重载，内置类型按字节拷贝，自定义类型调用其对应的
	//赋值重载
private:
	A a;
	int b;
};

int main()
{
	A a1;
	A a2;

	a2 = a1;
	return 0;
}

B类没有显示定义赋值重载，默认生成的赋值重载函数对于自定义类型会调用其自己的赋值重载，内置类型按照字节拷贝。

3.定义赋值重载函数，无论形参的类型是什么，赋值运算符重载都要定义为成员函数！！！

原因：赋值运算符在类中不显示实现，会默认的生成一个。此时如果在类外定义了一个全局的赋值重载函数，两个函数就会冲突。

class A
{
	//没有显示定义赋值重载，编译器自动生成一个
private:
	int _a;
	int _a2;
};

//定义全局的赋值重载函数
A& operator=(const A& left, const A& right)
{
	//....
}

int main()
{
	A a1;
	A a2;
	a1 = a2;
	return 0;
}

 需要注意的是，全局函数的参数没有this指针，所以需要传两个参数。

对于其他运算符重载，可以定义为全局函数，在传参的时候注意要传两个参数：

class A
{
public:
	A(int a1, int a2)
	{
		_a1 = a1;
		_a2 = a2;
	}
public:
	int _a1;
	int _a2;
};

//定义全局的赋值重载函数
bool operator==(const A& left, const A& right)
{
	cout << "全局运算符重载==" << endl;
	return left._a1 == right._a1
		|| left._a2 == right._a2;
}

int main()
{
	A a1(10,20);
	A a2(20,30);

	cout << (a1 == a2) << endl;
	return 0;
}

(a1 == a2) 等价于 operator=(a1,a2) ;

但是一般情况下，将运算符重载定义为成员函数更为常见，这是因为，类的成员变量一般都会设为私有，运算符重载经常要访问成员变量。上述代码为了演示将成员变量设为了公有。

4.当有资源申请，没有显示定义赋值重载的情况，可能会出现内存泄露和重复析构。（以Stack为例）：

class Stack
{
public:
	//构造函数
	Stack(size_t capacity = 10)
	{
		_array = (int*)malloc(sizeof(int)*capacity);
		_size = 0;
		_capacity = capacity;
	}
	//析构，有资源的申请，显示定义析构
	~Stack()
	{
		free(_array);
		_array = nullptr;
		_size = _capacity = 0;
	}

	//拷贝构造，有资源的申请，显示定义，深拷贝
	//用已有的对象构建新对象
	Stack(const Stack& st)
	{
		_array = (int*)malloc(st._capacity*sizeof(int));
		memcpy(_array, st._array, sizeof(int) * st._size);

		_size = st._size;
		_capacity = st._capacity;
	}
    
    //赋值重载没有显示定义，用默认生成的
	//赋值重载,将已经存在的对象赋值给另一个存在的对象
	//涉及资源的申请，如果用默认生成的赋值，会造成资源泄露和多次析构的问题


	void Push(const int val)
	{
		//简单模拟，不考虑扩容问题
		_array[_size++] = val;
	}
private:
	int* _array;
	int _size;
	int _capacity;
};

 

如上图分析，当涉及资源的申请时，要显示的定义合适的赋值重载：

	Stack& operator=(const Stack& st)
	{
		//自己赋值自己直接返回即可
		if (this != &st)
		{
			//先把旧的空间释放，再去拷贝
			free(_array);

			_array = (int*)calloc(st._capacity,sizeof(int));
			if (_array == nullptr)
			{
				perror("malloc失败！");
				exit(1);
			}
			memcpy(_array, st._array, sizeof(int) * st._size);
			_size = st._size;
			_capacity = st._capacity;
		}
		return *this;
	}

在上述代码中，还有一个细节，就是对自己赋值给自己的情况直接略过不进行处理，如果忽略了这种情况，可能会出现bug，以上述代码为例：

综上所述，在赋值重载的实现中，要注意自己给自己赋值的情况。 

取地址重载和const取地址重载

const成员

在类和对象上篇谈论过，隐含的this指针类型是T* const this。 const 修饰的是指针本身，禁止this指针改变指向。基于这种情况，如果我们有const对象调用成员函数的时候，const对象调用非const成员函数，是权限的放大，这样的调用是错误的。

class Date
{
public:
	void Fun()
	{
		//...
	}
private:
	int _year;
	int _month;
	int _day;
};

int main()
{
	const Date d1;
	d1.Fun();
	return 0;
}

上述的调用是const对象调用非const的成员函数，是权限的放大，不可以。下述代码是正确的写法：

class Date
{
public:
	Date() {}
	void Fun() const
	{
		//...
	}
private:
	int _year = 1;
	int _month = 2;
	int _day = 3;
};

int main()
{
	const Date d1;
	d1.Fun();
	return 0;
}

在函数后面加const修饰，const修饰的是this指针指向内容，表示在该成员函数中不能对类的成员变量进行修改。

 取地址和const取地址重载

这两个默认函数不写，编译器会默认生成。通常情况下，编译器默认生成的就足够满足我们的需求，它们的功能分别是对普通对象取地址和对const对象取地址。

class Date
{
public:
	Date* operator&()
	{
		return this;
	}
	const Date* operator&()const
	{
		return this;
	}
private:
	int _year = 1;
	int _month = 2;
	int _day = 3;
};

int main()
{
	const Date d1;
	Date d2;

	cout << &d1 << endl;
	cout << &d2 << endl;
	return 0;
}

 这两个默认成员函数一般不用显示的写，编译器默认生成的就足够用了。

小张爱写Bug
关注
  • 5
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
C++类和对象应用 - 日期类
02-07
一份完善的日期类源码
C++实验一-类与简单对象.doc
11-15
C++实验一-类与简单对象.doc
在C++中-＞运算符
ultramand的博客
12-14 4583
是C++中的成员访问运算符，用于通过指针访问对象的成员。它提供了一种方便的方式来访问指针所指向对象的成员，使得对象成员的访问更加简洁和直接。是一个运算符，称为成员访问运算符（Member Access Operator）。它用于通过指针访问对象的成员（变量或函数）。运算符允许通过指针访问对象的成员，相当于对指针所指向的对象使用成员访问运算符。它提供了一种方便的方式来访问指针所指向对象的成员，而无需先解引用指针再使用。，可以访问并修改指针所指向的对象的成员。是对象的成员（变量或函数）。是一个指向对象的指针，
C++ --- 对象指针
weixin_60413769的博客
03-21 1891
这里是Joe本人的学习笔记，如果能帮助到你，那我受宠若惊！ 对象指针的一般概念： 类的对象在初始化的时候会在内存中占有内存空间，既可以通过对象名，也可以通过对象地址来访问每个对象。（这时就用到了对象指针） 对象指针的声明： 语法形式： 类名*对象指针名； Point * pointer;//声明对象指针 Point p1;//创造对象 Pointper=&p1//把对象p1的地址赋给指针 用对象指针访问对象的成员： 对象指针名->成员名 指向类的非静态成员的指针、 指向对
C++中的.和-＞
weixin_44477424的博客
02-04 4352
C++中的.和->以及:: 1. C++中的点（.）的应用 如果是一个对象或者引用去调用成员变量或者成员函数函数的话，会使用到点 #include <iostream> using namespace std; class Base { public: Base(int a) { val = a; } void fun() { cout << "Base static fun" << endl; }
c++--类的定义
gaoxiaochan的博客
04-25 8135
17．类：是在C语言的struct类型上，增加了“成员函数”。 C的strcut可将一个概念或实体的所有属性组合在一起，描述同一类对象的共同属性。 C++进行了扩展，使得struct不但包含数据，还包含函数(方法)用于访问或修改类变量(对象)的属性。C++ 在 C 语言的基础上增加了面向对象编程，C++ 支持面向对象程序设计。类是 C++ 的核心特性，通常被称为用户定义的类型。 -->类用于指定对象的形式，它包含了数据表示法和用于处理数据的方法。类中的数据和方法称为类的成员。函数在一个类中被称为
C++的.和-＞的区别
qq_45701131的博客
09-07 3312
C++的.和->运算符的区别
C++-派生类的定义和使用
loglian的博客
05-04 5560
6-5派生类的定义和使用(10分) 按要求完成下面的程序： 1、定义一个Animal类，包含一个void类型的无参的speak方法，输出“animal language!”。 2、定义一个Cat类，公有继承自Animal类，其成员包括： （1）私有string类型的成员m_strName; （2）带参数的构造函数，用指定形参对私有数据成员进行初始化； （3）公有的成员函数print_name...
C++中的“-＞“的含义和用途
mw的博客
10-16 2576
在C++中，-> 是一个操作符，用于访问指向类对象的指针的成员。它通常用于类对象的指针，允许你通过指针访问该对象的成员变量和成员函数。
头歌C++ 面向对象 - 类和对象的创建和使用
qq_65628600的博客
05-05 8049
第1关:设计一个学生信息类： #include <iostream> using namespace std; class StInfo { /********* Begin *********/ public: //在此处声明StInfo类 int SID; char *Name; char *Class; char *Phone; void SetInfo(int sid,char *name,char *cla,char *phon
C++ ->和.的用法
qq_41859559的博客
05-11 3575
C++ ->和.的用法 c++中 . 和 -> 主要是用法上的不同。 1、A.B 则A为对象或者结构体； 2、A->B 则A为指针，->是成员提取。A->B是提取A中的成员B，A只能是指向类、结构、联合的指针； 例如： class student { public: string name[20]; } 第一种情况，采用指针访问 student *xy，则访问时需要写成 *xy.name=“hhhhh”；等价于度xy->name=“hhhhh”。 第二种情况，采用
C++-bind基本用法和作用
mrbone11的博客
10-26 5373
文章目录bind是什么bind怎么用bind作用bind绑定引用参数 bind是什么 bind是一个标准库函数，定义在functional头文件中。可以将bind函数看作一个通用的函数适配器，它接受一个可调用对象，生成新的可调用对象来适应原对象的参数列表。 bind怎么用 调用bind的一般形式为： auto newCallable=bind(callable,arg_list); newCallable和callable都是可调用对象，arg_list对应calllable的参数。当我们调用newCal
2.const对象-NULL和nullptr-C++中创建对象数组.docx
11-21
2.const对象-NULL和nullptr-C++中创建对象数组.docx
C++入门-初识类与对象
10-22
思维导图
Dev-C++编译程序器
07-31
C++既可以进行C语言的过程化程序设计，又可以进行以抽象数据类型为特点的基于对象的程序设计，还可以进行以继承和多态为特点的面向对象的程序设计。 C++擅长面向对象程序设计的同时，还可以进行基于过程的程序设计...
C语言 变量的存储类型
weixin_45966674的博客
05-21 198
今天 我们来说变量的存储类型变量的存储类型是指系统为变量分配存储区域的方式。决定着变量存储空间在哪里分配，和变量的生存期、作用域存在着一定联系。
Ubuntu16.04 opencv环境搭建（C++）
hkj887tg的博客
05-21 408
Ubuntu下vscode跑opencv程序环境搭建。
[C][数组]详细讲解
最新发布
SnowK博客
05-22 1370
[C][数组]详细讲解
C动态内存管理
aqiangdeba的博客
05-17 332
malloccallocreallocfree原则：谁申请，谁释放，防止内存泄漏在C语言中，当你传递一个指针给一个函数时，你实际上是传递了指针的副本，而不是指针本身。这意味着，虽然你在函数内部可以通过这个指针修改指向的内存，但对于指针本身的修改（例如将它指向一个新的内存地址），这种修改不会影响到函数外部指针的值。
c++面向对象-类和对象的创建和使用
08-12
C++是一种面向对象的编程语言，它支持类和对象的创建和使用。类是一种用户定义的数据类型，它封装了数据和方法，可以用来描述一个实体的属性和行为。对象是类的实例，它具有类定义的属性和行为。 在C++中，可以通过...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值