C++初阶：类和对象（下）

最新推荐文章于 2024-08-08 18:37:26 发布
最新推荐文章于 2024-08-08 18:37:26 发布
阅读量618 收藏 27
点赞数 27
分类专栏： C++：由浅入深篇 文章标签： c++ 初始化列表 explicit static成员 友元 内部类 匿名对象
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Zhihuiguoz/article/details/140892798
版权

✨✨小新课堂开课了，欢迎欢迎~✨✨

🎈🎈养成好习惯，先赞后看哦~🎈🎈

所属专栏：C++：由浅入深篇

小新的主页：编程版小新-CSDN博客

1.再探构造函数

1.1构造函数体内赋值

之前我们实现构造函数时，初始化成员变量主要使用函数体内赋值。 
class Date
{
public:
	//构造函数
	Date(int year = 1, int month = 1, int day = 1)
	{
		_year = year;
		_month = month;
		_day = day;
	}
private:
	int _year;
	int _month;
	int _day;
};

需要注意的是，上面构造函数的实现是使每个成员变量都有了一个初始值，但是构造函数体的语句其实只能被认为是赋值，而不是初始化，因为初始化只能初始化一次，而赋值可以有多次。

class Date
{
public:
	//构造函数
	Date(int year = 1, int month = 1, int day = 1)
	{
		_year = year;//第一次
		_year = 2024;//第二次
		_month = month;
		_day = day;
	}
private:
	int _year;
	int _month;
	int _day;
};

1.2初始化列表

构造函数初始化还有一种方式，就是初始化列表。

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

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

1.3小细节

一：每个成员变量在初始化列表中只能出现一次
语法理解上初始化列表可以认为是每个成员变量定义初始化的地方，初始化只能初始一次。
二：下面几个成员变量，必须在初始化列表初始化
1.const成员变量
const变量必须在定义的时候初始化，并且只有这一次初始化机会。而初始化列表就是成员变量定义初始化的地方，所以const成员变量必须在初始化列表初始化。
初始化： 
class Date
{
public:
	
	Date(int year = 1, int month = 1, int day = 1)
		:_year(year)
		, _month(month)
		, _day(day)
		, _a(1)
	{}
private:
	int _year;
	int _month;
	int _day;
	const int _a;
};

2.引用成员变量

引用必须初始化，在定义时就要给一个初始值，而初始化列表是每个成员变量定义初始化的地方，所以引用成员变量必须在初始化列表初始化。

初始化：

class Date
{
public:
	
	Date(int& xx,int year = 1, int month = 1, int day = 1)
		:_year(year)
		, _month(month)
		, _day(day)
		, _a(1)
		, _ra(xx)
	{}
private:
	int _year;
	int _month;
	int _day;
	const int _a;
	int& _ra;
};

3.自定义类型成员

若一个类没有默认构造函数，那我们在实例化类类型对象时就要传参对其初始化，所以没有默认构造的类类型变量，必须放在初始化列表位置就要初始化，否则会编译报错。

初始化： 
 class Time
{
public:
	Time(int hour)
		:_hour(hour)
	{
		cout << "Time()" << endl;
	}
private:
	int _hour;
};

class Date
{
public:
	Date(int& xx,int year = 1, int month = 1, int day = 1)
		:_year(year)
		, _month(month)
		, _day(day)
		, _a(1)
		, _ra(xx)
		,_t(1)
	{}
private:
	int _year;
	int _month;
	int _day;
	const int _a;
	int& _ra;
	Time _t;

};

总结：在定义时就必须要初始化的变量类型，必须在初始化列表初始化。

三：C++11支持持在成员变量声明的位置给缺省值，这个缺省值主要是给没有显示在初始化列表初始化的成员使用的。
如果这个成员在声明位置给了缺省值，初始化列表会用这个缺省值初始化。如果你没有给缺省值：
内置类型：否初始化取决于编译器，C++并没有规定。
自定义类型:调用这个成员类型的默认构造函数，如果没有默认构造会编译错误。
下面是给了缺省值的情况： 
#include<iostream>
using namespace std;

class Time
{
public:
	Time(int hour)
		:_hour(hour)
	{
	cout << "Time()" << endl;
	}
private:
	int _hour;
};
class Date
{
public:
	Date()
		:_month(2)
	{
		cout << "Date()" << endl;
	}
	void Print() const
	{
		cout << _year << "-" << _month << "-" << _day << endl;
	}
private:
	// 注意这里不是初始化，这里给的是缺省值，这个缺省值是给初始化列表的
	// 如果初始化列表没有显示初始化，默认就会用这个缺省值初始化
	int _year = 1;
	int _month = 1;
	int _day;
	Time _t = 1;
	const int _n = 1;
	int* _ptr = (int*)malloc(12);
};

四：尽量使用初始化列表初始化

因为初始化列表实际上就是当你实例化一个对象时，该对象的成员变量定义初始化的地方，所以 无论你是否使用初始化列表对成员变量初始化，都会走初始化列表。
对于内置类型，使用初始化列表或者构造函数体内赋值进行初始化时没有什么差别的。
对于自定义类型可以提高代码效率。 
class Time
{
public:
	Time(int hour = 0)
	{
		_hour = hour;
	}
private:
	int _hour;
};

class Date
{
public:
	// 使用初始化列表
	Date(int hour)
		:_t(12)// 调用一次Time类的构造函数
	{}
private:
	Time _t;
};

对于以上代码，当我们要实例化一个Date类的对象时，由于使用初始化列表进行初始化，在实例化过程中只调用了一次Time类的构造函数。
如果我们不使用初始化列表，使用构造函数体内赋值的话：

class Time
{
public:
	Time(int hour = 0)
	{
		_hour = hour;
	}
private:
	int _hour;
};
class Date
{
public:
	// 构造函数体内赋值
	Date(int hour)
	{ 
		Time t(hour);// 调用一次Time类的构造函数
		_t = t;// 调用一次Time类的赋值运算符重载函数
              //在此之前其实还会调用一次构造函数，因为_t是一个新的Time对象，它需要进行初始化
	}
private:
	Time _t;
};

这时，我们要实例化一个Datet类的对象时，在实例化Date对象时调用一次Time类的构造函数，然后还需要调用了一次Time类的赋值运算符重载函数，这样效率就降下来了。

五.成员变量在类中的声明顺序就是初始化列表初始化的顺序
初始化顺序跟成员在初始化列表出现的的先后顺序无关，建议声明顺序和初始化列表顺序保持⼀致。
下面我们看一道练习：
A. 输出 1 1
B. 输出 2 2
C. 编译报错
D. 输出 1 随机值
E. 输出 1 2
F. 输出 2 1 
//下面程序的运行结果是什么
#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，所以先初始化_a2，由于_a2是用_a1进行初始化的，而_a1还未被初始化，是个随机值，所以_a2最后是个随机值。后声明的_a1,然后在初始化_a1是1。这是虽然_a1是1了，但是_a2不会变成1，因为只能初始化一次，所以答案故选D。

2.隐式类型转换

我们在学习C语言时就知道，如果赋值两边的类型不同时就可能发生隐式类型转换。

隐式类型转换转换是由编译器自动进行的，无需程序员明确指定。

显示类型转换则是由程序员通过特定的语法明确指示编译器进行类型转换。

2.1内置类型

在发生隐式类型转换时，如果两边都是内置类型会生成一个临时变量（类型转换会生成临时变量）。将右操作数强制类型转换为左操作数的类型，最后用这个临时变量给左操作数赋值。临时变量具有常性，不能更改。

int main()
{
	double j = 1.1;
	int i = j;//隐式类型转换
	int& a = j;//error  权限放大
	const int& b = j;//正确 权限平移
	return 0;
}

 通过引用来测试，我们得知a，b，j指向同一块空间。a，b都是j的别名，然而只用常引用是可行的，这也验证了发生类型转换时产生的临时变量具有常性。

2.2自定义类型

在发生隐士类型转换时，如果将一个内置赋值给自定义类型，编译器产生一个自定义类型的临时变量，然后会调用这个自定义类型的构造函数初始化这个临时变量，最后用这个临时变量对左操作数进行拷贝构造。临时变量也具有常性，不可修改。

#include<iostream>
using namespace std;

class Date
{
public:
	Date(int year = 1, int month = 1, int day = 1)
	{
		_year = year;
		_month = month;
		_day = day;
	}
	Date(const Date& d)
	{
		_year = d._year;
		_month = d._month;
		_day = d._day;
	}
	void Print()
	{
		cout << _year << "-" << _month << "-" << _day << endl;
	}
private:
	int _year;
	int _month;
	int _day;
};
int main()
{
	Date d1 = 2024;//发生隐式类型转换
	Date d2 = { 2024,8 };

	d1.Print();
	d2.Print();
	return 0;
}

2.3explicit关键字 

C++支持内置类型隐式类型转换为类类型对象，需要有相关内置类型为参数的构造函数、 但当构造函数前面加explicit就不再支持隐式类型转换。 
#include<iostream>
using namespace std;

class A
{
public:
	// 构造函数explicit就不再支持隐式类型转换
	 explicit A(int a1)
		//A(int a1)
		:_a1(a1)
	{}
	explicit A(int a1, int a2)
	//A(int a1, int a2)
		:_a1(a1)
		, _a2(a2)
	{}
	void Print()
	{
		cout << _a1 << " " << _a2 << endl;
	}
private:
	int _a1 = 1;
	int _a2 = 2;
};
int main()
{
	// 1构造一个A的临时对象，再用这个临时对象拷⻉构造aa1
	// 编译器遇到连续构造+拷⻉构造->优化为直接构造
	A aa1 = 1;
	aa1.Print();
	const A& aa2 = 1;
	// C++11之后才支持多参数转化
	A aa3 = { 2,9 };
	aa3.Print();
	return 0;
}

3.static成员

3.1定义

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

class A
{
public:
    static int Print()//静态成员函数
	{
		cout << "Print()" << endl;
	}
private:
	static int _a;//静态成员变量
};

3.2小细节

1.静态成员变量一定要在类外进行定义初始化，定义时不添加static关键字。 
class A
{
public:
	static int Print()//静态成员函数
	{
		cout << "Print()" << endl;
	}
private:
	static int _a;//静态成员变量
};

int A::_a = 1;

这里静态成员变量_a虽然是私有，但是我们在类外突破类域直接对其进行了访问。这是一个特例，不受访问限定符的限制，否则就没办法对静态成员变量进行定义和初始化了。

2.静态成员变量为所有类对象所共享，不属于某个具体的对象，不存在对象中，存放在静态区。 
class A
{
public:
	static int Print()//静态成员函数
	{
		cout << "Print()" << endl;
	}
private:
	static int _a;//静态成员变量
};

int A::_a = 1;

int main()
{
	cout << sizeof(A) << endl;
	return 0;
}

最终计算的结果是1，因为静态成员_a存在静态区，属于整个类，也属于类的所有对象。所以在计算类的大小或则类对象的大小时，静态成员的大小并不算在其中。

3.静态成员函数没有this指针，可以访问其他的静态成员，但是不能访问非静态的。 
class Test
{
public:
	static void Fun()
	{
		cout << _a << endl; //error不能访问非静态成员
		cout << _n << endl; //正确
	}
private:
	int _a; //非静态成员
	static int _n; //静态成员
};

注意：非静态的成员函数，可以访问任意的静态成员变量和静态成员函数。
4.静态成员也是类的成员，受public、protected、private 访问限定符的限制。
所以当静态成员变量设置为private时，尽管我们突破了类域，也不能对其进行直接访问。
5.突破类域就可以访问静态成员，可以通过类名::静态成员 或者 对象.静态成员 来访问静态成员变量和静态成员函数。
1.当静态成员成员变量设置为公有时： 
class Test
{
public:
	static int _n; 
};

int Test::_n = 0;

int main()
{
	Test test;
	cout << test._n << endl; //1.通过类对象突破类域进行访问
	cout << Test::_n << endl; //2.通过类名突破类域进行访问
	return 0;
}

2.当静态成员变量被设置为私有时：

class Test
{
public:
	static int GetN()
	{
		return _n;
	}
private:
	static int _n;
};

int Test::_n = 0;

int main()
{
	Test test;
	cout << test.GetN() << endl; //1.通过对象调用成员函数进行访问
	cout << Test::GetN() << endl; //2.通过类名调用静态成员函数进行访问
	return 0;
}

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

4.友元

友元提供了一种突破类访问限定符封装的方式，友元分为：友元函数和友元类。

在函数声明或者类声明的前面加friend，并且把友元声明放到一个类的里面。

4.1友元函数 

我们有时想在类外面访问类的私有或保护成员，但是碍于访问限定符的限制，我们不能直接访问。如果一定要访问的话，我们就可以借助友元函数。

它的用法：friend+函数的声明

class Date
{
public:
	friend void Print(const Date& d);
	Date(int year = 1, int month = 1, int day = 1)
	{
		_year = year;
		_month = month;
		_day = day;
	}
	Date(const Date& d)
	{
		_year = d._year;
		_month = d._month;
		_day = d._day;
	}
	
private:
	int _year;
	int _month;
	int _day;
};
void Print(const Date& d)
{
	cout <<d._year<< "-" << d._month << "-" <<d. _day << endl;
}
注意：
友元函数仅仅是一种声明，他不是类的成员函数。
友元函数可以在类定义的任何地声方明，不受类访问限定符限制。
一个函数可以是多个类的友元函数。
友元函数不能被const修饰。
友元函数的调用和普通函数的调用原理相同。

4.2友元类

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

友元类的用法：friend+class+类名

#include<iostream>
using namespace std;
class A
{
	// 友元声明
	friend class B;//B类是A类的友元
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);
	bb.func2(aa);
	return 0;
}
注意：
1.友元类的关系是单向的，不具有交换性。
比如上面的代码B类是A类的友元，B类可以访问A类中的成员变量和成员函数，但是A类不是B类的友元，A就不能随意访问B类。
2.友元类关系不能传递
如果A类是B类的友元， B类是C类的友元，但是A类不是C类的友元。
3.有时提供了便利。但是友元会增加耦合度，破坏了封装，所以友元不宜多用。

5.内部类 

5.1定义

如果一个类定义在另一个类的内部，这个内部类就叫做内部类。
内部类是一个独立的类，不属于内部类，跟定义在全局相比，他只是受外部类类域限制和访问限定符限制，所以不能用外部类的对象去访问内部类的成员，外部类定义的对象中不包含内部类，并且 内部类默认是外部类的友元类。 
class A
{
public:
	class B//B类是A类的友元
	{
	private:
		int _j;
	};
private:
	int _a;
	int _b;
};

5.2小细节 

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

当A类跟B类紧密关联，如果放到private/protected位置，那么A类就是B类的专属内部类，其
他地方都用不了。
2.注意内部类可以直接访问外部类中的static成员，不需要外部类的对象 / 类名。 
include<iostream>
using namespace std;
class A
{
private:
	static int _k;
	int _h = 1;
public:
	class B // B默认就是A的友元
	{
	public:
			void foo(const A & a)
		{
			cout << _k << endl; //OK 直接访问static成员
			cout << a._h << endl; //OK
		}
	};
};

//static成员在外部定义初始化
int A::_k = 1;

int main()
{
	//B是一个独立的类，只是外部类类域的限制
	A::B b;
	A aa;
	b.foo(aa);
	return 0;
}

3.外部类的大小和内部类没有关系。

class A
{
private:
	int _n;
	int _m;
public:
	class B // B是A的友元
	{
	public:
		int _a;
	};
};
int main()
{
	A a;
	cout << sizeof(a) << endl;
	return 0;
}

 6.匿名对象

用类型(实参) 定义出来的对象叫做匿名对象，想必之前我们定义的 类型 对象名(实参) 定义出来的叫有名对象。
匿名对象⽣命周期只在当前一行，一般临时定义一个对象当前一下下即可，就可以定义匿名对象。 
class Date
{
public:
	Date(int year = 1, int month = 1, int day = 1)
	{
		cout << "Date" << endl;
		_year = year;
		_month = month;
		_day = day;
	}
	Date(const Date& d)
	{
		cout << "Date(const Date& d)" << endl;
		_year = d._year;
		_month = d._month;
		_day = d._day;
	}
	void Print()
	{
		cout << _year << "/" << _month << "/" << _day << endl;
	}
	~Date()
	{
		cout << "~Date()" << endl;
		_year = _month = _day = 0;
	}
private:
	int _year;
	int _month;
	int _day;
};
int main()
{
	Date();//匿名对象
	return 0;
}

 要延长匿名对象的生命周期，一种常见的方法是将其绑定在引用上。

int main()
{
	const Date& dc = Date();//匿名对象也具有常性
	return 0;
}

编程版小新
关注
  • 27
    点赞
  • 踩
  • 27
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++初阶：类和对象
weixin_36194037的博客
09-21 252
C++初阶：类和对象
C++初阶：类和对象（上）
Zhihuiguoz的博客
07-23 964
C++类与对象是面向对象编程（OOP）的基础。OOP通过类和对象的概念简化了软件开发过程。本篇博客将为您提供类和对象的精简总结，帮助你快速把握OOP的核心。
C++初阶：类和对象（三）
QinMou
07-18 851
初始化列表的使⽤⽅式是以⼀个冒号开始，接着是⼀个以逗号分隔的数据成 员列表，每个"成员变量"后⾯跟⼀个放在括号中的初始值或表达式。
C++初阶：类和对象(上)
weixin_63143943的博客
08-22 464
C++ 类和对象
C++初阶：类和对象（一）——类的创建与使用
Crazy_Rabbits的博客
03-04 1277
class Name//类体：由成员变量和成员函数组成//分号是不可以省略的成员函数如果在类中定义，编译器可能会将其处理为内联（inline）函数int num;（2）类声明之后，类中函数在类外定义，此时需要加上::域限定作用符int num;在一般的情况下，我们更推荐采用第二种做法，便于适应日后工程化编程的需求。
C++初阶：类与对象（一）
QinMou
07-10 1193
⾯向对象三⼤特性：封装、继承、多态
C++初阶：类与对象(下)
weixin_63143943的博客
09-04 464
类与对象详解
C++初阶：类与对象（中篇）
qq_71806743的博客
03-09 895
构造函数在整个对象的声明周期中会自动调用，且调用一次构造函数只负责初始化不会开辟空间构造函数的形式： 函数名与类名相同 无返回值 实例化对象会自动调用相应的构造函数 构造函数可以重载默认生成的构造函数class Datepublic:int _year;int _month;int _day;Date d1;d1.Print();_top = top;
c++初阶 类和对象 中级篇
01-22
"C++类和对象中级篇" 本篇文章讲解了C++中类和对象的中级知识，涵盖了类的6个默认成员函数、构造函数、析构函数、拷贝构造函数、赋值运算符重载、日期类的实现等内容。 一、类的6个默认成员函数 在C++中，如果一...
C++初阶+类和对象（上）.pdf
01-17
C++初阶+类和对象（上） 本节课将介绍C++中的类和对象的概念，包括面向过程和面向对象的初步认识、类的引入、类的定义、类的访问限定符及封装、类的作用域、类的实例化、类对象模型、this指针等内容。 1. 面向过程...
C++类和对象练习 实现日期类
07-29
为了更好的理解`C++`类和对象的知识,我们可以动手实现一下`C++`的一个简单的日期类,完成相应的函数,更好的帮助我们理解类和对象. 从日期类的构造函数,拷贝构造,获取当月天数,日期与天数的运算,日期类相关的比较...
C++初阶 - 入门.pdf
01-15
C++初阶 - 入门.pdf C++是一种功能强大且灵活的编程语言，它是由Bjarne Stroustrup在1983年开发的。C++是C语言的超集，添加了对象导向编程的特性，使得编程更加灵活和高效。 1. C++98标准 C++98是C++语言的第一个...
C++入门（初阶）
11-22
这个是百度之星上面的小教程，自己整理成了pdf文档。对于C++新手来讲，照着打一遍会对该语言有个大致的了解。其框架，结构等等。当然，该教程并没有设计面向对象，甚至没有涉及数组和指针。只是入门基础。
STL中的迭代器失效（vector为例）
2302_80190394的博客
08-08 214
STL中的迭代器失效（vector为例）
c++ error: ‘*’ does not name a type； did you mean ‘**’?
最新发布
xiaozhi
08-08 91
c++ error: ‘*’ does not name a type； did you mean ‘**’?
C++ STL copy_backward, move_backward 用法
08-04 282
此处需要解释一下：从后向前并不是逆序，它的意思是: 源容器和目标容器都从尾部开始，然后向前迭代，执行拷贝/移动操作。反向（从后向前的顺序）拷贝/移动操作，将一个容器元素拷贝/移动到另一容器中。
C++ - 函数重载
jiaowenjie的专栏
08-06 276
/打印的是第二个函数的地址。//打印的是第一个函数的地址。-> 重载函数在本质上是相互独立的不同函数。-> 函数返回值不能作为函数重载的依据。-> 重载函数的函数类型不同。**3.函数默认参数和函数重载****函数重载的注意事项：****4.函数重载的本质**
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值