C++类和对象(下)

目录

一、再谈构造函数

1.1  构造函数体赋值

1.2  初始化列表 

1.3  explicit关键字

二、static成员

2.1  概念

2.2  特性

三、友元

3.1  友元函数

3.2  友元类

四、内部类

五、匿名对象

六、拷贝对象时的一些编译器优化

---

一、再谈构造函数

1.1  构造函数体赋值

虽然下面的构造函数调用后能给成员变量一个初始值，但是不能将其称为对对象中成员变量的初始化，构造函数体中的语句只能将其称为赋初值，而不能称作初始化。

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

因为构造函数能调用多次，而初始化只能初始化一次。

1.2  初始化列表 

首先要知道不管是内置类型(int ,char...)还是自定义类型，构造函数不管有没有显示写初始化列表，创建的时候都先要走初始化列表，内置类型如果没写初始化列表，如果构造函数给初始值那就是初始值，否则是随机值，自定义类型在初始化列表没初始化，就会调用它的默认构造函数。

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

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

	}

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

初始化列表的注意事项：

1. 每个成员变量在初始化列表只能出现一次（只能初始化一次）
2. 下面几种 成员是必须要在初始化列表初始化的：

• 引用成员变量

class B
{
public:
	//error C2530: “B::_b”: 必须初始化引用
	B()
	{
	}

	//正确玩法
	B(int b = 0)
		: _b(b)
	{

	}
	

private:
    //因为是取别名，所以必须要初始化
	int& _b;
};

• const修饰的成员变量

class B
{
public:
	// error C2789: “B::_n”: 必须初始化常量限定类型的对象
	B()
	{

	}

	//正确玩法：
	B()
		:_n(10)
	{

	}

private:
	const int _n;
};

• 自定义类型成员(当没有默认构造时)

class A
{
public:
	//不是默认构造, 报错
	A(int a)
		:_a(a)
	{

	}

private:
	int _a;
};


class B
{
public:
	//如果初始化列表没有_aa的初始化，就会自动调用默认构造函数
	B()
	{
	}

	//走初始化列表初始化
	B(int aa = 0)
		:_aa(aa)
	{
	}

private:
	A _aa;
};

 大家看看下面的代码运行的结果是什么？？？

class A
{
public:
    A(int a)
       :_a1(a)
       ,_a2(_a1)
   {}
    
    void Print() {
        cout<<_a1<<" "<<_a2<<endl;
   }
private:
    int _a2;
    int _a1;
};
int main() {
    A aa(1);
    aa.Print();
}
//A. 输出1  1
//B.程序崩溃
//C.编译不通过
//D.输出1  随机值

 答案是：D

解析：成员变量在类中声明次序就是其在初始化列表中的初始化顺序，与其在初始化列表中的先后 次序无关。声明顺序是先_a2,后_a1，所以初始化列表先是初始化_a2(_a1)，此时的_a1是随机值，然后初始化成了随机值，然后再走_a1(a),此时a=1，所以结果是1  随机值。

1.3  explicit关键字

在explicit关键字学习中需要引入隐式类型的转换的知识，单参数的构造函数支持的隐式类型的转换。

class Date
{
public:
	//单值的构造函数
	Date(int year)
        :_year(year)
	{
		
	}

	//拷贝构造
	Date(const Date& d)
	{
		_year = d._year;
	}

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


int main()
{
	Date d1(2024);
	//隐式类型的转换
	Date d2 = 2024;

	const Date& d3 = 2024;

	return 0;
}

其中涉及到编译器的一些优化，了解即可。 

如果不想要隐式类型转换发生，那就在构造函数前加explicit关键字即可。

---

二、static成员

2.1  概念

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

class A
{
public:
	A(int a = 0)
		// error C2438: “_a”: 无法通过构造函数初始化静态类数据
		:_a(a)
	{

	}
private:
	static int _a;
};


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

 下面的代码运行结果是什么？？？

class A
{
    public:
    A() { ++_scount; }
    A(const A& t) { ++_scount; }
    ~A() { --_scount; }
    static int GetACount() { return _scount; }
    private:
    static int _scount;
};

int A::_scount = 0;

void TestA()
{
    cout << A::GetACount() << endl;
    A a1, a2;
    A a3(a1);
    cout << A::GetACount() << endl;
}

运行结果：

0
3

不能在类中初始化静态成员变量的原因：

用static修饰的成员变量是存在内存中的静态区(数据段)，它不存在栈上，不会随着对象生命周期的结束而销毁，所以每次创建对象时在初始化列表初始化的时候都是改变的同一个值。

2.2  特性

1. 静态成员为所有类对象所共享，不属于某个具体的对象，存放在静态区
2. 静态成员变量必须在类外定义，定义时不添加static关键字，类中只是声明
3. 类静态成员即可用 类名::静态成员 或者 对象.静态成员 来访问
4. 静态成员函数没有隐藏的this指针，不能访问任何非静态成员
5. 静态成员也是类的成员，受public、protected、private 访问限定符的限制

---

三、友元

友元是C++提供了一种可以打破封装的办法，有时确实能提供遍历。但友元会增加耦合度，破坏了封装，所以友元不宜多用。

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

3.1  友元函数

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

class Date
{
	//在类里用friend关键字声明成友元函数后，该函数能访问类的私有变量
	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& out, const Date& d)
{
	out << d._year << "-" << d._month << "-" << d._day;
	return out;//返回值是为了链式插入 cout << d1 << d2;
}

// >> 流提取的符号重载
istream& operator>>(istream& in, Date& d)
{
	in >> d._year >> d._month >> d._day;
	return in;//返回值是为了链式提取 cin >> d1 >> d2;
}

int main()
{
	Date d;
	cin >> d;
	cout << d << endl;
	return 0;
}

注意事项：

• 友元函数可访问类的私有和保护成员，但不是类的成员函数
• 友元函数不能用const修饰
• 友元函数可以在类定义的任何地方声明，不受类访问限定符限制
• 一个函数可以是多个类的友元函数
• 友元函数的调用与普通函数的调用原理相同

3.2  友元类

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

class B
{
public:
	//声明 A类 为时 B类 的友元类，则在 A类 中就直接访问 B类 中的私有成员变量
	friend class A;

	B(int b = 0)
		:_b(b)
	{

	}
private:
	int _b;
};


class A
{
public:
	A(int a = 0)
		:_a(a)
	{

	}

	void GetAData(int b)
	{
		//直接访问A类私有的成员变量
		_bb._b = b;
	}

private:
	int _a;
	B _bb;
};

 注意事项：

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

        比如上述A类和B类，在B类中声明A类为其友元类，那么可以在A类中直接访问B类的私有成员变量，但想在B类中访问A类中私有的成员变量则不行。

• 友元关系不能传递 如果C是B的友元， B是A的友元，则不能说明C时A的友元。
• 友元关系不能继承，在继承位置再给大家详细介绍。

---

四、内部类

一个类定义在一个类的内部，内部类就称为内部类。内部类是一个独立的类，它不属于外部类，更不能在外部类的对象去访问内部类的私有变量。

内部类天生是外部类的友元类。

class A
{
public:
    class B // B天生就是A的友元
    {
    public:
        void f(const A& a)
        {
            cout << _k << endl;//OK
            cout << a._h << endl;//OK
        }
    };

private:
    static int _k;
    int _h;
};

int A::_k = 1;

int main()
{
    A::B b;
    b.f(A());

    return 0;
}

注意事项：

• 内部类可以定义在外部类的public、protected、private都是可以的。
• 注意内部类可以直接访问外部类中的static成员，不需要外部类的对象/类名。
• sizeof(外部类)=外部类，和内部类没有任何关系。

---

五、匿名对象

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

};


int main()
{
	//报错，不能这么定义对象，因为编译器识别不清是函数调用还是创建对象。
	//A aa1();
	A aa1;

	//但是我们可以这样定义匿名对象，特点是不用取名
	A();//但是它声明周期只有一行，下一行就会调用析构函数

	//以前的玩法
	Solution s1;
	s1.Sum_Solution(10);

	//匿名函数的玩法：
	Solution().Sum_Solution(10);//匿名对象例如在这样场景下就很好用
	
	return 0;
}

六、拷贝对象时的一些编译器优化

我们拿vs编译器来举例

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

构造+拷贝构造+拷贝构造  --->  构造+拷贝构造

如果创建对象是用引用创建，那就没有优化可言了，因为只有构造。

还有一种不能够优化的场景：

拷贝构造和赋值拷贝就不能够优化了。

---

最后，谢谢您的阅读！！！

您的点赞、关注和评论就是我写文章的最大动力嗷，让我们一起共同进步！！！！