初始化列表、static成员、友元

最新推荐文章于 2024-07-24 11:32:27 发布
最新推荐文章于 2024-07-24 11:32:27 发布
阅读量98 收藏
点赞数
分类专栏： C++入门 文章标签： c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_51210661/article/details/116973293
版权

文章目录

再谈构造

在创建对象时，编译器通过调用构造函数，给对象中各个成员变量一个合适的初始值。

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

虽然上述构造函数调用之后，对象中已经有了一个初始值，但是不能将其称作为类对象成员的初始化，造函数体中的语句应该只能将其称作为赋初值，而不能称作初始化。因为初始化只能初始化一次（即定义的时候初始化），而构造函数体内可以多次赋值。
私有域内的数据里面定义的数据是声明，当我们创建对象调用构造函数进行初始化的时候其就是类似于：

int i;//先定义
i=1;//后赋值

若是成员变量中有const、引用等一些定义时就要初识话的变量怎么办？
举个栗子

class Date
{
public:
	Date(int year, int month, int day,int i)
	{
		_year = year;
		_month = month;
		_day = day;
		_i = i;//出错，const值不可改变
	}
	void print()
	{
		cout << _year << " - " << _month << " - " << _day << endl;
	}
private:
	int _year;
	int _month;
	int _day;
	const int _i;
};

这样怎么解决？
简单，直接定义的时候初始化

const int _i=0;

但是这样的话，那我后面定义对象时并不想定义_i=0怎么办？

初始化列表

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

#include<iostream>
using namespace std;
class Date
{
public:
	Date(int year = 2021, int month = 5, int day = 18,int i=5)
		:_year(year), 
		_month(month), 
		_day(day),
		_i(i)
	{
	}
private:
	int _year;
	int _month;
	int _day;
	const int _i;
};
int main()
{
	Date d;
	d.print();
}

这样编译器没有报错
用初始化列表初始化时类似于直接在声明处定义时初始化。

const int _i=i;//可以理解为用初始化列表时，其就直接在声明那里初始化

注意

  1. 每个成员变量在初始化列表中只能出现一次(初始化只能初始化一次)
  2. 类中包含以下成员，必须放在初始化列表位置进行初始化：
    引用成员变量
    const成员变量
    自定义类型成员(没有默认构的造函数如:无参、全缺省）
class A {
public:
	A(int a)
		:_a(a)
	{}
private:
	int _a;
};
class B {
public:
	B(A a, int ref,int n)
		:_aobj(a)
		, _ref(ref)
		, _n(10)
	{}
private:
	A _aobj; // 没有默认构造函数
	int& _ref; // 引用
	const int _n; // const 
};

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

class A {
public:
	A(int a=1)
		:_a(a)
	{
		cout << "A(int a=1)" << endl;
	}
	A& operator=(const A&a)
	{
			cout << "A& operator=(const A&a)" << endl;
			return *this;
	}
private:
	int _a;
};
class B {
public:
	//B(A a, int b)
	//	:_a(a),
	//	_b(b)
	//{
	//	cout << "B(A a, int b):_a(a),_b(b)" << endl;
	//}	
	B(A a, int b)
	{
		_a = a;
		cout << "B(A a, int b)"<<endl;
	}
private:
	A _a;
	int _b;
};
int main()
{
	A a;
	B b(a,1);
}

不使用初始化列表
在这里插入图片描述

	B(A a, int b)
		:_a(a),
		_b(b)
	{
		cout << "B(A a, int b):_a(a),_b(b)" << endl;
	}	
	//B(A a, int b)
	//{
	//	_a = a;
	//	cout << "B(A a, int b)"<<endl;
	//}

使用初始化列表
在这里插入图片描述
内置类型无所谓，但是自定义类型推荐使用初始化列表，不用初始化列表他也要走初始化列表，而且也会调赋值运算符重载那个函数

看下面代码：

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

应该是哪个结果
输出1 1
程序崩溃
编译不通过
输出1 随机值
答案是： 输出1 随机值
所以有个细节是：成员变量在类中声明次序就是其在初始化列表中的初始化顺序，与其在初始化列表中的先后次序无关。

匿名对象
匿名对象就是定义对象时对象没有名字，直接传参，看下面这代码：

class A
{
public:
	A(int a)
	{
		_a = a;
		if(_a)cout <<"A(int a)" << endl;
		else cout << "匿名对象：A()" << endl;
	}
	~A()
	{
		if (_a)cout <<"~A()"<<endl;
		else cout << "匿名对象：~A()" << endl;//匿名对象析构时输出
	}
private:
	int _a;
};
int main()
{
	A a(1);
	A(0);//匿名对象传0，这里用来控制类里的输入
	A b(3);
}

结果：
在这里插入图片描述
这里可以看出匿名对象的声明周期只在他定义的那一行（走完那一行直接析构），而普通对象的声生命周期是main函数域（main函数结束时析构）。
还是上面这个函数，重新定义对象：

class A
{
public:
	A(int a)
	{
		_a = a;
		if(_a)cout <<"A(int a)" << endl;
		else cout << "匿名对象：A()" << endl;
	}
	~A()
	{
		if (_a)cout <<"~A()"<<endl;
		else cout << "匿名对象：~A()" << endl;
	}
	A(const &Aa)
	{
		cout<<"拷贝构造A(const &Aa)"<<endl;
	}
private:
	int _a;
};
int main()
{
	A a(1);
	A b = 0;
	A c(2);
}

在这里插入图片描述
A b=0;这里原本是先调用匿名构造出一个匿名对象（隐式类型转换），在把匿名对象传给拷贝构造，拷贝给b。但是从这里里看出显然没有调用匿名对象（若有的话，他的构造函数后就应该连着他的析构）和拷贝构造啊，这好像调用的是b的构造函数啊。
其实这是编译器优化后吧两个过程给优化合并了，直接调用了构造函数。
当然A b=0;这种只是用于单参数构造函数。
为什么要有这种匿名对象，后面关于string类的时候就会用到了。

explicit关键字
构造函数不仅可以构造与初始化对象，对于单个参数的构造函数，还具有类型转换的作用（就是上面讲得匿名对象）。用explicit修饰构造函数，将会禁止单参构造函数的隐式转换，即就定义类时就不能使用匿名构造临时对象了。
如将上面的构造函数：

explicit A(int a)

在这里插入图片描述

static成员

有没有什么办法可以表明我用这个类创建了多少对象，可以试试static成员。
声明为static的类成员称为类的静态成员，用static修饰的成员变量，称之为静态成员变量；用static修饰的成员函数，称之为静态成员函数。静态的成员变量一定要在类外进行初始化。
静态成员属于类的所有对象，局部静态变量 从静态存储区域分配，其在第一次初始化后 就一直存在直到程序结束。该变量的特点是 其作用域只在定义它的函数内可见，出了该 作用域变量就不可见了。
他是存储在静态区的不在类内空间，所以在计算类大小的时候不计算他。

class A
{
public:
	A(int a = 1)
	{
		_a = a;
		_b++;
	}
	static void f()//静态成员函数没有this指针，所以其不能访问私有域内的非静态成员
	{
		//_b =_a;不能访问，会报错
		cout << _b << endl;
	}
private:
	int _a;
	static int _b;//静态成员变量只能在类外初始化
};
int A::_b = 0;//类外初始化
int main()
{
	A a;
	a.f();
}

静态成员特性：

  1. 静态成员为所有类对象所共享，不属于某个具体的实例
  2. 静态成员变量必须在类外定义，定义时不添加static关键字
  3. 类静态成员即可用类名::静态成员或者对象.静态成员来访问
  4. 静态成员函数没有隐藏的this指针，不能访问任何非静态成员
  5. 静态成员和类的普通成员一样，也有public、protected、private3种访问级别，也可以具有返回值

C++11支持非静态成员变量在声明时进行初始化赋值，但是要注意这里不是初始化，这里是给声明的成员变量缺省值。

class B 
{
public:
 B(int b = 0)
 :_b(b)
 {
 }
 int _b;
};
class A 
{
public:
 void Print()
 {
 cout << a << endl;
 cout << b._b<< endl;
 cout << p << endl;
 }
private:
 // 非静态成员变量，可以在成员声明时给缺省值。
 int a = 10;
 B b = 20;
  int* p = (int*)malloc(4);
 static int n;
};
int A::n = 10;
int main()
{
 A a;
 a.Print();
 return 0; 
}

在这里插入图片描述

“<<”输出运算符重载与友元

如果我们想用cout输出对象，那么就需要重载cout了：
cout是属于ostream类型的，所以我们可以尝试写出下面这种代码

class Date
{
public:
	Date(int  year=2021, int month=5, int day=18)
		:_year(year),
		_month(month),
		_day(day)
	{

	}
	void operator <<(ostream& c)
	{
		c << _year << "-" << _month << "-" << _day;
	}
private:
	int _year;
	int _month;
	int _day;
};
int main()
{
	Date d;
	d << cout;
	cout << endl;
}

因为在类里面，成员函数的第一个参数是隐藏的this指针，，所以我们重载好后的cout输出会有点奇怪。
但是在类里面第一个参数一直是this指针，这怎么办呢，把他放在类外试试？
但是放在外面就不能访问对象内私有变量了，那要怎么办？这是可以引进友元，友元分为：友元函数和友元类友元提供了一种突破封装的方式，有时提供了便利。但是友元会增加耦合度，破坏了封装，所以友元不宜多用。

class Date
{
	friend void operator <<(ostream& c, const Date &d);
public:
	Date(int  year=2021, int month=5, int day=18)
		:_year(year),
		_month(month),
		_day(day)
	{

	}
private:
	int _year;
	int _month;
	int _day;
};
void operator <<(ostream& c,const Date &d)
{
	c << d._year << "-" << d._month<< "-" << d._day;
}
int main()
{
	Date d;
	cout << d;
	cout << endl;
}

这时格式就一样了，但是如果我要连续输出多个对象呢？怎么办？如上代码如果cout<<d的返回值是cout是不是就可以解决问题了，即：

class Date
{
	friend ostream& operator <<(ostream& c, const Date &d);
public:
	Date(int  year=2021, int month=5, int day=18)
		:_year(year),
		_month(month),
		_day(day)
	{

	}
private:
	int _year;
	int _month;
	int _day;
};
ostream& operator <<(ostream& c,const Date &d)
{
	c << d._year << "-" << d._month<< "-" << d._day;
	return c;
}
int main()
{
	Date d;
	Date a(2021,5,19);
	Date b(2021,5,20);
	cout << a<<endl<<b<<endl<<d<<endl;
}

在这里插入图片描述
友元函数可以直接访问类的私有成员，它是定义在类外部的普通函数，不属于任何类，但需要在类的内部声明，声明时需要加friend关键字。
友元函数可访问类的私有和保护成员，但不是类的成员函数
注意
友元函数不能用const修饰
友元函数可以在类定义的任何地方声明，不受类访问限定符限制
一个函数可以是多个类的友元函数
友元函数的调用与普通函数的调用和原理相同

友元类
友元类的所有成员函数都可以是另一个类的友元函数，都可以访问另一个类中的非公有成员。友元关系是单向的，不具有交换性。
比如在B类中声明A类为其友元类，那么可以在B类中直接访问A类的私有成员变量，但想在A类中访问B类中私有的成员变量则不行。友元关系不能传递如果B是A的友元，C是B的友元，则不能说明C时A的友元。

class B;//前置声明
class A
{
	friend class B;//声明B类为A类的友元类，则在B类中就直接访问A类中的私有成员变量
public:
	A(int a = 1)
		:_a(a)
	{
	}
private:
	int _a;
};
class B
{
public:
	B(int b = 1)
	{
		_b=b;
		a._a = _b;//直接访问A a的私有成员
	}
	void print()
	{
		cout << "_b:" << _b << endl <<"a._a:"<< a._a << endl;
	}
private:
	int _b;
	A a;
};
int main()
{
	B b;
	b.print();
}

在这里插入图片描述
内部类
概念：如果一个类定义在另一个类的内部，这个内部类就叫做内部类。注意此时这个内部类是一个独立的类，它不属于外部类，更不能通过外部类的对象去调用内部类。外部类对内部类没有任何优越的访问权限。
注意：内部类就是外部类的友元类。注意友元类的定义，内部类可以通过外部类的对象参数来访问外部类中的所有成员。但是外部类不是内部类的友元。
特性：

  1. 内部类可以定义在外部类的public、protected、private都是可以的。
  2. 注意内部类可以直接访问外部类中的static、枚举成员，不需要外部类的对象/类名。
  3. sizeof(外部类)=外部类，和内部类没有任何关系。
class A {
private:
 static int k;
 int h;
public:
 class B
 {
 public:
 void foo(const A& a)
 {
 cout << k << endl;//OK
 cout << a.h << endl;//OK
 }
 };
};
int A::k = 1;
int main()
{
 A::B b;
 b.foo(A());
 
 return 0; }

内部类天生就是外部类的友元，内部类就像友元类一样的这种意思，想让外面访问就公有域，否则就私有域。
计算类大小时是不计算所含的内部类的。

再次理解封装
C++是基于面向对象的程序，面向对象有三大特性即：封装、继承、多态。
C++通过类，将一个对象的属性与行为结合在一起，使其更符合人们对于一件事物的认知，将属于该对象的所有东西打包在一起；通过访问限定符选择性的将其部分功能开放出来与其他对象进行交互，而对于对象内部的一些实现细节，外部用户不需要知道，知道了有些情况下也没用，反而增加了使用或者维护的难度，让整个事情复杂化。
可以感觉到面向对象其实是在模拟抽象映射现实世界。
在这里插入图片描述

Gy不太冷
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
实验三 静态成员和友元.zip
11-30
// 在全局范围内初始化静态成员 ``` 友元则是一种打破封装机制的机制，它允许一个类访问另一个类的私有或保护成员。这在某些情况下是必要的，例如实现复杂的关联结构或者提供特定的访问权限。声明友元的方式如下：...
C++实验报告四--静态成员与友元.docx
02-27
`，并且在全局作用域中初始化`Stack::num=0;`以确保在使用前有初始值。 其次，友元是C++中解决封装问题的一种方式。友元函数或友元类可以访问另一个类的私有和保护成员，即使这些成员在通常情况下是不可见的。在本...
类中static成员初始化
csdn_walter的博客
09-21 1322
类中static成员初始化
成员初始化列表顺序
雪儿的专栏
07-28 471
常量必须在构造函数初始化列表里面初始化，或者将其设置为static. class A{ A() {      const int size=7; } }; 或者 class A{ stattic const int Size=9;   //去掉static后是错误的。 }；
c语言中int year,大神来帮帮我int countDays(int year,i
weixin_33054119的博客
05-19 502
该楼层疑似违规已被系统折叠隐藏此楼查看此楼大神来帮帮我int countDays(int year,int month,int day){int sum;switch(month){case 1: sum=0;break;case 2: sum=31;break;case 3: sum=59;break;case 4: sum=90;break;case 5: sum=120;break;cas...
java：给定一个时日期，加上天数之后，输出加上天数后的日期。
iilegend的博客
05-18 3894
    public static void main(String[] args) throws ParseException { plusDay(18,"2018-05-18"); } /** * 指定日期加上天数后的日期 * @param num 为增加的天数 * @param newDate 创建时间 * @return * @t...
C++第六弹 -- 类与对象下篇(初始化列表 Static成员 友元 内部类 匿名对象)
酷酷学!!!的博客
07-14 1003
本篇文章介绍了类和对象初始化列表, 静态成员变量以及静态成员函数, 友元, 以及内部类和匿名对象, 希望能够帮助读者更好的理解类和对象博客主页:酷酷学!!!(点关注不迷路)正文开始初始化列表本质上是类成员变量定义的地方，它提供了一种在构造函数中初始化成员变量的方式，特别是对于引用、const和自定义类型成员变量，必须使用初始化列表。static成员是类的成员，但与特定对象无关，所有类对象共享一个static成员。静态成员变量需要在类外定义，静态成员函数没有隐含的this指针，不能访问非静态成员。
类和对象（3）初始化列表 static成员 友元 内部类 匿名对象 拷贝对象时的一些编译器优化
weixin_63666347的博客
12-26 113
问题：现在尝试去重载operator
C++：初始化列表，static成员，友元，内部类
li209779的博客
09-16 748
本篇博客作为C++：初始化列表，static成员，友元，内部类的知识总结。以上就是我对于初始化列表，static成员，友元，内部类，匿名对象的知识总结。！！
【C++】类与对象 （四）初始化列表 static成员 友元 内部类 匿名对象 拷贝对象时的一些编译器优化
一点一点变好
02-18 684
【C++】类与对象 （四）初始化列表 static成员 友元 内部类 匿名对象 拷贝对象时的一些编译器优化
C++类和对象(下)——初始化列表、static成员和友元
03-10 7824
C++类和对象——初始化列表、static成员和友元一、再谈构造函数1.1 构造函数整体赋值1.2 初始化列表三级目录 关于C++类和对象的学习 C++类和对象(上)——类的基本概念、类的限定符及封装和类成员函数的this指针 C++类和对象(中)——类的6个默认成员函数(构造、析构、拷贝构造、赋值运算符重载) 一、再谈构造函数 1.1 构造函数整体赋值 在创建对象时，编译器通过调用构造函数，给对象中各个成员变量一个合适的初始值。例如我们之前创建的Date类 class Date { public: D
C++实验报告四--静态成员与友元.pdf
02-27
构造函数`Stack::Stack()`初始化链表头指针`Head`，析构函数`~Stack()`没有显示定义，但通常会负责释放链表中的所有节点。`Push`方法用于向栈中插入元素，通过动态分配新的节点并连接到链表尾部来实现。`Empty`方法...
C++程序设计课件：第15章 静态成员与友元.ppt
05-29
静态数据成员的空间分配有三个可能的地方：(1) 作为类的静态数据成员在类外分配空间和初始化;(2) 作为类的静态数据成员，在类内分配空间和初始化;(3) 作为全局变量或全局对象在类外分配空间和初始化。 十五点四 ...
C 程序设计课件：第15章 静态成员与友元.ppt
06-18
因为函数在程序运行中被调用，所以静态数据成员不能在任何函数内分配空间和初始化。 静态成员函数 静态成员函数不仅可以通过类对象来访问，还可通过“类名 :: 静态成员函数”的形式在程序中直接调用。例如： ```...
C++构造函数初始化列表+Static成员+友元
weixin_41368411的博客
04-12 820
一.初始化列表 1.构造函数体赋初值 以下面的代码为例，在类的构造函数中，给对象的成员变量赋初值。 class Date { public: Date(int year, int month, int day) { _year = year; _month = month; _day = day; flag = 1; } private: int _year; // 声明 int _month; int _day; const int flag; }; int
C语言 之 理解指针（1）
fallzzzzz的博客
07-20 1183
就是先获取该数组的首元素的地址，从前面我们知道，指针的类型的作用是指针+1 所跳过的字节数，int为整形，大小为4个字节，所以p+1就跳过4个字节，p+2就跳过8个字节，计算机的CPU（中央处理器）在处理数据的时候，需要的数据是在内存中读取的，处理后数据也会放回内存中，如果想对这些空间进行高效的管理，就可以。并且我们知道，数组的元素存放是随着下标增长，内存地址变大的。上面的代码创建了一个整型变量n，因为一个整形的大小是4个字节，所以内存中申请了4个字节，⽤于存放整数10，其中每个字节都有地址。
VS2019编译和使用gtest测试（C++）
最新发布
m0_65635427的博客
07-24 266
下载下来解压到文件夹，再在文件夹里面新建一个build文件夹，如下：再安装cmake，可以先检查一下是否安装了cmake，打开命令窗口，输入cmake -version：然后双击就对了，我这里已经安装好了，无法提供截图，注意一点就是在让选择是否建立系统环境变量（path）的时候，记得勾上第二个建立系统环境变量！下载好之后，记得检验一下是否安装成功，如果在普通用户下显示没有，建议用管理员身份打开命令窗口，再次尝试。之后命令窗口进入创建的build文件夹路径里面执行cmake ../
【C++修炼之路 第五章】string 类（补充）：string 扩展空间规律 + reserve 的缩容 + resize 的使用
唯有忍受别人不能忍受的，才能享受别人不能享受的
07-23 1126
【详细剖析】string 扩展空间规律 + reserve 的缩容性质与只改变capacity的性质 + resize 的使用 + shink_to_fit 的缩容函数
私有静态成员初始化
05-24
但是由于私有静态成员只能在类内访问，因此在类外进行初始化时需要使用类的友元函数或者静态成员函数进行赋值。 例如： ```c++ class MyClass { private: static int myPrivateStaticVar; public: static void ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值