初始化列表&static成员&友元&内部类&匿名对象

Echo_Aran

已于 2023-09-17 18:56:03 修改

阅读量112

点赞数

分类专栏： C++修习之路文章标签： c++ 数据结构

于 2023-05-18 16:12:30 首次发布

本文链接：https://blog.csdn.net/qq_73881574/article/details/130655547

版权

C++修习之路专栏收录该内容

14 篇文章 0 订阅

订阅专栏

1.再谈构造函数

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初始化列表

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

初始化列表是类成员的定义位置。

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.类中包含以下成员，必须放在初始化列表初始化：

（1）引用成员变量

（2）const成员变量

（3）自定义类型成员且该类没有构造函数的

特征：都需要在定义的时候完成初始化

class A
{
public:
	A(int a = 0) 
		:_a(a) 
	{
		cout << "A(int a=0)" << endl;
	};
private:
	int _a;
};
class B
{
public:
	//初始化列表：对象成员的定义位置
	B(int a, int ref)
		:_ref(ref)
		, _n(1)
		 {}

private:
	A _aobj;//没有默认构造函数

	//特征：必须在定义的时候初始化
	int& _ref;	//引用
	const int _n;	//const
	int _x = 1;		//只是声明 这里的1是缺省值，缺省值是给初始化列表的

};

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

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

1.3 构造函数的类型转换

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

将参数转换为自定义类型，在调用拷贝构造。

但经过编译器的优化以后，可以用2直接构造。

class A
{
public:
	A(int a = 0) 
		:_a(a) 
	{
		cout << "A(int a=0)" << endl;
	};
private:
	int _a;
};

int main()
{
	A aa1(1);
	A aa2 = 2;//隐式类型转换，整形转换成自定义类型
	//	2构造一个A的临时对象，临时对象再拷贝构造 aa2-->优化以后：用2 直接构造aa2

	//A& aa3 = 2;	//error:“初始化”: 无法从“int”转换为“A & ”
	const A& aa3 = 2;

}

使用explicit修饰构造函数，可以禁止类型转换

class Date
{
public:
 // 1. 单参构造函数，没有使用explicit修饰，具有类型转换作用
 // explicit修饰构造函数，禁止类型转换---explicit去掉之后，代码可以通过编译
     explicit Date(int year)
     :_year(year)
     {}
}

2.static成员

2.1概念

声明为static的类成员称为类的静态成员，用static修饰的成员变量，称之为静态成员变量；

用static修饰的成员函数，称之为静态成员函数。

静态成员变量一定要在类外初始化。

静态成员变量是类对象中所有的成员变量，不应该依赖于实例对象的创建。

类外定义成员变量可以保证只被初始化一次

2.2特性

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

2.静态成员变量不使用初始化列，表必须在类外定义（不依赖于实例对象的创建，只初始化一次）定义时不添加static关键字，在类中只是声明

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

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

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

class A
{
public:
	A() 
	{
		++_scount;
	}

	A(const A& t) 
	{
		++_scount;
	}

	~A() 
	{ 
		--_scount;
	}


	void Func1()
	{
		// 非静态能否调用静态：可以
		GetACount();
	}

	void Func2()
	{
		++_a1;
	}

	// 没有this指针，指定类域和访问限定符就可以访问
	static int GetACount() 
	{ 
		// 静态能否调用非静态：不可以。非静态的成员函数调用需要this指针，我没有this
		// Func2();

		//_a1++;
		return _scount;
	}
private:
	// 成员变量 -- 属于每个一个类对象，存储对象里面
	int _a1 = 1;
	int _a2 = 2;
//public:
	// 静态成员变量 -- 属于类，属于类的每个对象共享，存储在静态区
	static int _scount;
};

// 类成员变量必须全，类外面定义 全局位置
//定义时不加static关键字
int A::_scount = 0;

A aa0;

void Func()
{
	static A aa2;
	cout << __LINE__ << ":" << aa2.GetACount() << endl;

	// 全局变量的劣势：任何地方都可以随意改变
	//_scount++;
}

int main()
{
	cout <<__LINE__<<":"<< A::GetACount() << endl;  // 1
	A aa1;
	
	Func();  // 3
	Func();  // 3

	return 0;


// 设计一个类，在类外面只能在栈上创建对象

class A
{
public:
	static A GetStackObj()
	{
		A aa;
		return aa;
	}

	static A* GetHeapObj()
	{
		return new A;
	}
private:
	A()
	{}

private:
	int _a1 = 1;
	int _a2 = 2;
};

int main()
{
	//static A aa1;   //  静态区
	//A aa2;          //  栈 
	//A* ptr = new A; //  堆
	A::GetStackObj();
	A::GetHeapObj();

	return 0;
}

3.友元

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

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

3.1友元函数

问题：

现在尝试去重载operator<<，然后发现没办法将operator<<重载成成员函数。因为cout的输出流对象和隐含的this指针在抢占第一个参数的位置。this指针默认是第一个参数也就是左操作数了。但是实际使用中cout需要是第一个形参对象，才能正常使用。所以要将operator<<重载成全局函数。但又会导致类外没办法访问成员，此时就需要友元来解决。operator>>同理。

友元函数不具备this指针（不属于该类）

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

3.2友元类

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

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

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

友元关系不能传递

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

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

class Time
{
	friend class Date;
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 = 1945, int month = 1, int day = 1)
		:_year(year)
		, _month(month)
		, _day(day)
	{}

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

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

4.内部类

概念：

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

注意：

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

特性：

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

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

3.sizeof（外部类）=外部类，和内部类没有任何联系。（内部类是一个独立的类）

class A
{
private:
	static int k;
	int h;

public:
	class B
	{
	public:
		void func(const A& a)
		{
			cout << k << endl;
			cout << a.h << endl;
		}

	private:
		int b;
	};
};
int A::k = 1;

int main()
{
	cout << sizeof(A) << endl;
	//输出结果为： 4
	//说明内部类B是一个独立的类，它不属于外部类 外部类对内部类没有任何优越的访问权限
	//内部类就是外部类的友元类 

	cout << sizeof(A::B) << endl;

	//B b;//不能直接访问
	A::B b; //要加作用域才能访问
}

5.匿名对象（也称临时对象）

1.产生匿名对象的三种情况：
（1）以值的方式给函数传参；
Cat(); —> 生成了一个匿名对象，执行完Cat( )代码后，此匿名对象就此消失。这就是匿名对象的生命周期。
Cat cc = Cat(); —>首先生成了一个匿名对象，然后将此匿名对象变为了cc对象，其生命周期就变成了cc对象的生命周期。

(2）类型转换；

3）函数以值的形式需要返回一个对象时；return temp;

2.匿名对象的生命周期

如果生成的匿名对象在外部有对象等待被其实例化，此匿名对象的生命周期就变成了外部对象的生命周期；

如果生成的匿名对象在外面没有对象等待被其实例化，此匿名对象将会生成之后，立马被析构。

class C
{
public:
	C(int a = 0)
		:c(a)
	{}

private:
	int c;
};

class Solution
{
public:
	int Sum_Solution(int n)
	{
		cout << " Sum_Solution" << endl;
		return n;
	}
};

void push_back(const string& s)
{
	cout << "push_back" << s << endl;
}

//匿名对象

int main()
{
	C c(1);   //有名对象-------生命周期在当前函数局部区域
	C(1);	  //匿名对象———生命周期只在当前行


	Solution s1;
	s1.Sum_Solution(10);

	Solution().Sum_Solution(10);

	//C& rc =C(1);			//匿名对象具有常性
	const C& rc = C(1);		//const引用延长匿名对象的生命周期，生命周期在当前函数局部域	


	//匿名对象的实际操作
	string str("1111");
	push_back(str);

	push_back(string("1111"));


	push_back("1111");

	return 0;
}

class D
{
public:
	D(int d = 0)
		:_d(d)
	{
		cout << "D(int d)" << endl;
	}

	D(const D& dd)
		:_d(dd._d)
	{
		cout << "D(const D& dd)" << endl;
	}

	D& operator=(const D& d)
	{
		cout << "D& operator=(const D& d)" << endl;
		if (this != &d)
		{
			_d = d._d;
		}
		return *this;
	}

	~D()
	{
		cout << "~D()" << endl;
	}
private:
	int _d;
};


void Func1(D dd)
{

}

void Func2(const D& dd)
{

}

D Func3()
{
    D dd;
    return dd;
}

D& Func4()
{
    static D dd;
    return dd;
}

int main()
{
    D d1;
    Func1(d1);
    Func2(d1);

    Func3();
    Func4();


    return 0;
}