C++类和对象（4）

wangchen_0

于 2024-09-14 17:56:06 发布

阅读量424

点赞数 10

文章标签： c++ 开发语言

本文链接：https://blog.csdn.net/wangchen_0/article/details/142210959

版权

1. 再探构造函数

之前我们实现构造函数时，初始化成员变量主要在构造函数体内赋值，构造函数初始化还有⼀种方

式，就是初始化列表，初始化列表的使用方式是以⼀个冒号开始，接着是⼀个以逗号分隔的数据成

员列表，每个"成员变量"后⾯跟⼀个放在括号中的初始值或表达式。

（1）每个成员变量在初始化列表中只能出现⼀次，语法理解上初始化列表可以认为是每个成员变量定义初始化的地方。

（2） 引用成员变量，const成员变量，没有默认构造的类类型成员变量，必须放在初始化列表位置进行初始化，否则会编译报错，这三种情况的共同点是都需要在定义时初始化。

（3）C++11支持在成员变量声明的位置给缺省值，这个缺省值主要是给没有显示在初始化列表初始化的成员使用的。

#include<iostream>
using namespace std;

class Time
{
public:
	//不是默认构造函数
	Time(int hour)
		:_hour(hour)
	{
		cout << "Time()" << endl;
	}
private:
	int _hour;
};

class Date
{
public:
	//
	Date(int& x, int year = 1, int month = 1, int day = 1)
		:_year(year)
		//,_year(year)成员Date::_year不能初始化
		, _month(month)
		, _day(day)
		//以下三种必须放在初始化列表初始化
		, _t(12)
		, _ref(x)
		, _n(1)
	{
		// error C2512: “Time”: 没有合适的默认构造函数可⽤
		// error C2530 : “Date::_ref” : 必须初始化引⽤
		// error C2789 : “Date::_n” : 必须初始化常量限定类型的对象
	}
	void Print()const
	{
		cout << _year << "-" << _month << "-" << _day << endl;
	}
private:
	int _year;
	int _month;
	int _day;
	Time _t; // 没有默认构造
	int& _ref; // 引⽤
	const int _n; // const

//	// 注意这⾥不是初始化，这⾥给的是缺省值，这个缺省值是给初始化列表的
 如果初始化列表没有显⽰初始化，默认就会⽤这个缺省值初始化
//	int _year = 1;
//	int _month = 1;
//	int _day;
//	Time _t = 1;
//	const int _n = 1;
};

int main()
{
	int i = 0;
	Date d1(i);
	d1.Print();
	return 0;
}

（4）尽量使用初始化列表初始化，因为那些你不在初始化列表初始化的成员也会走初始化列表，如果这个成员在声明位置给了缺省值，初始化列表会用这个缺省值初始化。如果你没有给缺省值，对于没有显示在初始化列表初始化的内置类型成员是否初始化取决于编译器，C++并没有规定。对于没有显示在初始化列表初始化的自定义类型成员会调用这个成员类型的默认构造函数，如果没有默认构造会编译错误。

（5）初始化列表中按照成员变量在声明类中的顺序进行初始化，跟成员在初始化列表出现的的先后顺序无关。建议声明顺序和初始化列表顺序保持⼀致。

#include<iostream>
using namespace std;
class A
{
public:
	A(int a)
		:_a1(a)
		, _a2(_a1)
	{}
	void Print() {
		cout << _a1 << " " << _a2 << endl;
	}
private:
	int _a2 = 2;
	int _a1 = 2;
};
int main()
{
	A aa(1);
	aa.Print();
}

先初始化_a2得到随机值，在初始化_a1为1

初始化列表总结：

无论是否显示写初始化列表，每个构造函数都有初始化列表；

无论是否在初始化列表显示初始化，每个成员变量都要走初始化列表初始化；

using namespace std;

class Time
{
public:
	//是默认构造函数
	Time(int hour = 4)
		:_hour(hour)
	{
		cout << "Time()" << endl;
	}
private:
	int _hour;
};

class Date
{
public:
	//
	Date(int& x, int year = 1, int month = 1, int day = 1)
	{

	}
	void Print()const
	{
		cout << _year << "-" << _month << "-" << _day << endl;
	}
private:
	int _year;
	int _month;
	int _day;
	Time _t; 

};

int main()
{
	int i = 0;
	Date d1(i);
	d1.Print();
	return 0;
}

调用了Time类初始化_t。

下面是一个成员变量初始化逻辑表。

2.类型转换

两个类型之间有一定的关联才能进行转换。算数类型之间能互相转换是因为它们都能表示数据点的大小，指针和整形之间是因为指针本身是一个地址的编号，也能表示数据大小。c++中的内置类型要转换成自定义类型要借助构造函数。

内置类型—-》自定义类型

（1）C++支持内置类型 隐式类型转换为 类类型对象，需要有相关内置类型为参数的构造函数。

#include<iostream>
using namespace std;

class A
{
public:

	A(int a1)
		:_a1(a1)//2赋值给了a1,a2用缺省值初始化
	{
		cout << "A(int a)" << endl;
	}

	void Print()
	{
		cout << _a1 << " " << _a2 << endl;
	}

private:
	int _a1 = -1;
	int _a2 = -2;
};
int main()
{
	A aa1 = 2;
	aa1.Print();

	return 0;
}

（2）构造函数前面加explicit就不再支持隐式类型转换。

#include<iostream>
using namespace std;

class A
{
public:
	// 使用构造函数explicit就不再⽀持隐式类型转换
	// explicit A(int a1)  报错：无法从int转换到“A”
	A(int a1)
		:_a1(a1)
	{
		cout << "A(int a)" << endl;
	}
	//explicit A(int a1, int a2)
	A(int a1, int a2)
		:_a1(a1)
		, _a2(a2)
	{
		cout << "A(int a1, int a2)" << endl;
	}
	void Print()
	{
		cout << _a1 << " " << _a2 << endl;
	}
private:
	int _a1 = -1;
	int _a2 = -2;
};
int main()
{
	//单参数隐式类型转换
	A aa1 = 2;
	aa1.Print();
    //多参数隐式类型转换
	//错误写法：A aa2 = { 1,1 };
	const A& aa2 = { 1,1 };

	//临时对象为常量，只使用引用会导致权限放大
	//错误写法：A & aa3 = 1;
	const A& aa3 = 1;

	return 0;
}

（3）类类型的对象之间也可以隐式转换，需要相应的构造函数支持。

#include<iostream>
using namespace std;

class A
{
public:
	A(int a1)
		:_a1(a1)
	{
		cout << "A(int a)" << endl;
	}
	//explicit A(int a1, int a2)
	A(int a1, int a2)
		:_a1(a1)
		, _a2(a2)
	{
		cout << "A(int a1, int a2)" << endl;
	}
	void Print()
	{
		cout << _a1 << " " << _a2 << endl;
	}
private:
	int _a1 = -1;
	int _a2 = -2;
};

class Stack
{
public:
	void Push(const A& aa)
	{}
	//...
};
int main()
{
	Stack st;
	//A aa1(5);
	//st.Push(aa1);
	st.Push(5);

	//A aa2(6, 6);
	//st.Push(aa2);
	st.Push({ 6, 6 });
	return 0;
}

调用了构造函数：

自定义类型——》自定义类型

#include<iostream>
using namespace std;

class A
{
public:
	A(int a1)
		:_a1(a1)
	{
		cout << "A(int a)" << endl;
	}

	A(int a1, int a2)
		:_a1(a1)
		, _a2(a2)
	{
		cout << "A(int a1, int a2)" << endl;
	}
	void Print()
	{
		cout << _a1 << " " << _a2 << endl;
	}
	int Get() const
	{
		return _a1 + _a2;
	}
private:
	int _a1 = -1;
	int _a2 = -2;
};

class B
{
public:
	B(const A& a)
		:_b(a.Get())
	{}
private:
	int _b = 0;
};
int main()
{
	A aa1 = { 6,6 };
	B b = aa1;
	const B& rb = aa1;
	return 0;
}

3.static成员

（1）用static修饰的成员变量，称之为静态成员变量，静态成员变量⼀定要在类外进进初始化。

（2）静态成员变量为所有类对象所共享，而不是每个对象都有一份独立的副本，无论创建多少个对象，静态成员变量都只有一个，存放在静态区。

（3）突破类域就可以访问静态成员，可以通过类名::静态成员或者对象.静态成员来访问静态成员变量和静态成员函数。

#include<iostream>
using namespace std;

class A
{
public:
	A()
	{
		_scount++;
		cout << "A()" << endl;
	}
	A(const A& t)
	{
		_scount++;
		cout << "A(const A& t)" << endl;
	}
	~A()
	{
		--_scount;
		cout << "~A" << endl;
	}
//private:
	//类里面声明
	static int _scount;
};
//类外初始化
int A::_scount = 0;

void Func(A aa)
{}

int main()
{
	A aa1;//调用A()
	A aa2 = aa1;//调用A(const A& t)
	Func(aa1);//进入函数时调用A(const A& t),出来时调用~A()
	cout << A::_scount << endl;
	cout << aa1._scount << endl;
	return 0;//程序结束时调用~A,~A析构aa1,aa2
}

（4）用static修饰的成员函数，称之为静态成员函数，静态成员函数没有this指针。

（5）静态成员函数中可以访问其他的静态成员，但是不能访问非静态的，因为没有this指针。非静态的成员函数，可以访问任意的静态成员变量和静态成员函数。

（6）静态成员也是类的成员，受public、protected、private 访问限定符的限制。

（7）静态成员变量不能在声明位置给缺省值初始化，因为缺省值是个构造函数初始化列表的，静态成员变量不属于某个对象，不走构造函数初始化列表。

#include<iostream>
using namespace std;

class A
{
public:
	A()
	{
		_scount++;
		cout << "A()" << endl;
	}
	A(const A& t)
	{
		_scount++;
		cout << "A(const A& t)" << endl;
	}
	~A()
	{
		//非静态可以访问静态
		//GetACount();
		--_scount;
		cout << "~A" << endl;
	}
	static int GetACount()
	{
		//静态不能访问非静态
		//++i;
		return _scount;
	}
private:
	//不能在声明时给缺省值
	//static int _scount = 0;
	static int _scount;
	int i = 0;
};
//类外初始化
int A::_scount = 0;

void Func(A aa)
{}

int main()
{
	cout << A::GetACount() << endl;
	A a1, a2;
	A a3(a1);
	cout << A::GetACount() << endl;
	cout << a1.GetACount() << endl;
	return 0;
}

4.友元函数

友元函数是一种可以访问类的私有成员的非成员函数。

（1）友元提供了⼀种突破类访问限定符封装的方式，友元分为：友元函数和友元类，在函数声明或者类声明的前面加friend，并且把友元声明放到⼀个类的里面。

（2）外部友元函数可访问类的私有和保护成员，友元函数仅仅是⼀种声明，它不是类的成员函数。

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

（4）⼀个函数可以是多个类的友元函数。

#include<iostream>
using namespace std;

//友元函数：只能使特定的一个函数有权访问类的私有成员
//友元类：友元类的所有成员都可以访问另一个类的私有成员
// 前置声明，否则在声明友元函数Func1时A的友元函数声明编译器不认识B
class B;

class A
{
	//友元函数声明，可以让函数Func1访问类A的私有成员
	friend void Func1(const A& aa, const B& bb);
private:
	int _a1 = 1;
	int _a2 = 2;
};

class B
{
	friend void Func1(const A& aa, const B& bb);
private:
	int _b1 = 3;
	int _b2 = 4;
};

void Func1(const A& aa, const B& bb)
{
	cout << aa._a1 << endl;
	cout << bb._b1 << endl;
}
void Func2(const A& aa, const B& bb)
{
	//不可访问
	//cout << aa._a1 << endl;
}

int main()
{
	A aa;
	B bb;
	Func1(aa, bb);//1 3
	return 0;
}

（5）友元类中的成员函数都可以是另⼀个类的友元函数，都可以访问另⼀个类中的私有和保护成员。

（6）友元类的关系是单向的，不具有交换性，比如A类是B类的友元，但是B类不是A类的友元。

（7）友元类关系不能传递，如果A是B的友元， B是C的友元，但是A不是C的友元。

（8）有时提供了便利。但是友元会增加耦合度，破坏了封装，所以友元不宜多用。

#include<iostream>
using namespace std;

class A
{
	//友元函数声明,类B中的函数均可访问类A的私有成员变量
	friend class B;
private:
	int _a1 = 1;
	int _a2 = 2;
};

class B
{
public:
	void func1(const A& aa)
	{
		cout << aa._a1 << endl;
		cout << _b1 << endl;
	}
	void func2(const A& aa)
	{
		cout << aa._a2 << endl;
		cout << _b2 << endl;
	}
private:
	int _b1 = 3;
	int _b2 = 4;
};
int main()
{
	A aa;
	B bb;
	bb.func1(aa);//1 3
	bb.func2(aa);//2 4
	return 0;
}

5.内部类

（1）如果⼀个类定义在另⼀个类的内部，这个内部类就叫做内部类。内部类是⼀个独立的类，跟定义在全局相比，它只是受外部类类域限制和访问限定符限制，所以外部类定义的对象中不包含内部类。

（2）内部类默认是外部类的友元类。可以访问直接访问外部类的成员变量和方法，包括私有成员变量，但是外部类不能直接访问内部类的成员，除非通过内部类的对象进行访问。

（3）内部类本质也是⼀种封装，当A类跟B类紧密关联，A类实现出来主要就是给B类使用，那么可以考虑把A类设计为B的内部类，如果放到private/protected位置，那么A类就是B类的专属内部类，其它地方都用不了。

#include<iostream>
using namespace std;

class A
{
private:
	static int _k;
	int _h = 1;
public:
	class B // B默认就是A的友元
	{
	public:
		void func1(const A& a)
		{
			cout << _k << endl; //OK
			cout << a._h << endl; //OK
		}
	};
};
int A::_k = 1;
int main()
{
	cout << sizeof(A) << endl;
	// 受到外部类类域的限制
	//B b;
	A::B b;
	A aa;

	b.func1(aa);
	return 0;
}

6.匿名对象

（1）用类型(实参) 定义出来的对象叫做匿名对象，之前我们定义的类型对象名(实参) 定义出来的叫有名对象

（2）匿名对象生命周期只在当前一行，通常只用与一次性使用的场景。

#include<iostream>
using namespace std;

class A
{
public:
	A(int a = 0)
		:_a(a)
	{
		cout << "A(int a)" << endl;
	}
	~A()
	{
		cout << "~A()" << endl;
	}
private:
	int _a;
};
class Solution {
public:
	int Sum_Solution(int n) {
		//...
		return n;
	}
};

void fun(A aa = A(1))//aa._a =1
{

}
int main()
{
	A aa1;
	// 不能这么定义对象，因为编译器⽆法识别下⾯是⼀个函数声明，还是对象定义
	//A aa1();
	// 但是我们可以这么定义匿名对象，匿名对象的特点不⽤取名字，
	// 但是它的⽣命周期只有这⼀⾏，我们可以看到下⼀⾏他就会⾃动调⽤析构函数
	A();
	A(1);
	A aa2(2);
	// 匿名对象在这样场景下就很好⽤，当然还有⼀些其他使⽤场景，这个我们以后遇到了再说
	
	cout << Solution().Sum_Solution(10) << endl;
	fun();
	return 0;
}

（3） const修饰匿名对象，匿名对象的生命周期会被延长

#include<iostream>
using namespace std;

class A
{
public:
	A(int a = 0)
		:_a(a)
	{
		cout << "A(int a)" << endl;
	}
	~A()
	{
		cout << "~A()" << endl;
	}
private:
	int _a;
};
int main()
{
	const A& r = A(1);
	A aa1;
	A(2);
	return 0;//A(1)知道这一步才调用析构函数
}