文章目录
- 1. 再谈构造函数
- 2. Static成员
- 3. 友元
- 4. 内部类
- 5.匿名对象
- 6.拷贝对象时的一些编译器优化
- 7. 再次理解封装
提示:以下是本篇文章正文内容,下面案例可供参考
一、构造函数和初始化列表
初始化列表是用来初始化类的,虽然我们可以使用构造函数来初始化但是它和初始化列表不同
构造函数可以多次赋值,而初始化列表只能初始化一次。
(1)初始化列表
初始化列表:以一个冒号开始,接着是一个以逗号分隔的数据成员列表,每个"成员变量"后面跟 一个放在括号中的初始值或表达式。
class Date
{
public:
Date( )//初始化列表
:_year(2022)
,_month(11)
,_day(11)
{
;
}
Date( int year,int month,int day)//初始化列表,不想用默认值
:_year(year)
,_month(month)
,_day(day)
{
;
}
void print()const
{
cout << _year << "/" << _month << "/" << _day;
}
private:
int _year;
int _month;
int _day;
};
int main()
{
Date d(11);
d.print();
return 0;
}
(2)初始化列表的初始化顺序
成员变量在类中声明次序就是其在初始化列表中的初始化顺序,与其在初始化列表中的先后 次序无关
class A { public: A(int a) :_a1(a) ,_a2(_a1)//先初始化_a2,后初始化_a1 {} void Print() { cout<<_a1<<" "<<_a2<<endl; } private: int _a2; int _a1; }; int main() { A aa(1); aa.Print();// _a1输出1 _a2 随机值 }
(3)初始化列表初始化
在之前编译器自动生成的默认构造函数,它不会对内置类型初始化,C++对它打了个补丁,就是声明变量的时候可以给缺省值,这里的缺省值就是给初始化列表的默认值,当然如果初始化列表已经赋值,缺省值无效。
1. 每个成员变量在初始化列表中只能出现一次(初始化只能初始化一次)
2. 类中包含以下成员,必须放在初始化列表位置进行初始化: 引用成员变量 const成员变量 自定义类型成员(且该类没有默认构造函数时)
初始化列表可以解决构造函数解决不了引用和const变量,引用和const修饰的变量定义的时候必须给赋值。在用栈实现队列的时候,自定义类型调用它的默认构造函数,但是如果没有默认构造函数,已有的构造函数是需要传参的,就需要初始化列表
class A
{
public:
A(int a)//不是默认构造函数,需要传参
:_a(a)
{}
private:
int _a;
};
class B
{
public:
B(int a, int ref)
:_aobj(a)
, _ref(ref)
, _n(10)//初始化列表解决自定义类型初始化
{}
private:
A _aobj; //自定义类型同时它没有默认构造函数
int& _ref; // 引用
const int _n; // const
};
尽量使用初始化列表初始化,对于自定义成员的变量,初始化列表是最先执行的
(4)初始化列表和构造函数体的使用
既然初始化列表可以解决大部分初始化问题,但是缺少检查,比如对于栈开空间需要检查是否开辟成功。我们可以用初始化列表初始化,函数体内检查。
Stack()
:*a((int*)malloc(sizeof(int)*3)
,top(0)
{
if(a==nullptr)
{
return -1;
}
]
(5)explicit 关键字
构造函数可以用来初始化对象,同时对于单个参数或者除第一个参数无默认值其余均有默认值 的构造函数,还具有类型转换的作用。
class Date
{
public:
// 1. 单参构造函数,没有使用explicit修饰,具有类型转换作用
// explicit修饰构造函数,禁止类型转换---explicit去掉之后,代码可以通过编译
Date(int year)
:_year(year)
{}
/*
// 2. 虽然有多个参数,但是创建对象时后两个参数可以不传递,没有使用explicit修饰,具
有类型转换作用
// explicit修饰构造函数,禁止类型转换
explicit Date(int year, int month = 1, int day = 1)
: _year(year)
, _month(month)
, _day(day)
{}
*/
Date& operator=(const Date& d)
{
if (this != &d)
{
_year = d._year;
_month = d._month;
_day = d._day;
}
return *this;
}
private:
int _year;
int _month;
int _day;
};
int main()
{
Date d1(2022);
// 用一个整形变量给日期类型对象赋值
// 实际编译器背后会用2023构造一个无名对象,最后用无名对象给d1对象进行赋值
d1 = 2023;
return 0;
}
二.static关键字
(1)特性
static 修饰的变量和函数是这个类所共有的,所有该类的对象都可以访问它,可以理解为对象的全局函数和变量,也受限制符的限制。在类里面声明,在类外定义
1.修饰变量
它不属于对象,当是对象可以访问,也可以通过类域访问,当然它也受private等限制
2.修饰函数
static修饰的函数,可以访问static变量,它没有隐藏的this指针,所以访问不了对象的成员。
不过既然是对象共享,对象是可以访问这个静态函数的
1. 静态成员为所有类对象所共享,不属于某个具体的对象,存放在静态区
2. 静态成员变量必须在类外定义,定义时不添加static关键字,类中只是声明
3. 类静态成员即可用 类名::静态成员 或者 对象.静态成员 来访问
4. 静态成员函数没有隐藏的this指针,不能访问任何非静态成员
5. 静态成员也是类的成员,受public、protected、private 访问限定符的限制
【问题】 1. 静态成员函数可以调用非静态成员函数吗?
不可以,没有this指针
2. 非静态成员函数可以调用类的静态成员函数吗?
可以
(2)访问static变量
1.通过类域
2.通过对象(static变量不存在对象里,但是编译器把它解释成到该对象的类域中寻找)
3.通过临时对象,临时对象生命周期只存在临时变量所在的这一行
class A
{
public:
A() { ++_scount; }
A(const A & t) { ++_scount; }
~A() { --_scount; }
static int GetACount() { return _scount; }//static 函数
private:
static int _scount;//static 变量在类中声明,类外定义属于这个类
};
int A::_scount = 0;//类外定义
void TestA()
{
cout << A::GetACount() << endl;
A a1, a2;
A a3(a1);
cout << A::GetACount() << endl;
}
int main()
{
cout << A::GetACount() << endl;//通过域名
A a;
cout << a.GetACount() << endl;//通过对象
cout << A().GetACount() << endl;//匿名对象,生命周期只在这一行
return 0;
}
(3)调用静态函数
1.使用类域调用
2.对象调用/匿名对象

三,友元
(1).友元函数
友元函数可以直接访问类的私有成员,它是定义在类外部的普通函数,不属于任何类,但需要在 类的内部声明,声明时需要加friend关键字。
/友元
class A {
public:
A()
:_a(1)
,_b(1)
{}
friend void print(A &d);//声明为友元函数,如果注释掉这行,print就访问不了_a,_b
private:
int _a;
int _b;
};
void print(A&d)
{
cout <<d._a <<d._b << endl;
}
int main()
{
A a;
print(a);return 0;
}
(2)友元函数的特点
1.一个函数可以被多个类申明为友元函数
2.不是成员函数,不可以加const
3.在类里面申明,在类外面定义,没有隐藏的指针
2.友元类调用过程和普通函数相同
(2)友元类
//友元
class A {
friend class B;
private:
int _a;
int _b;
};
class B {
public:
void print()//在B类中访问a的成员
{
_j = a._a;
}
private:
int _j;
A a;
};
在类里面把一个类申明为友元类
特点:1.友元类可以访问类的protect和protect变量
2. 关系是单向的,友元类可以访问类所有成员但是类却不可以访问友元类的私有成员
3.友元关系不可以传递 A被B声明为友元类,B被C声明为友元类但是A不是C的友元类
4.友元关系不可以通过继承传递
四.内部类
(1)概念
1.如果一个类定义在另一个类的内部,这个内部类就叫做内部类,它是一个独立的类。内部类是外部类的友元,它可以通过的对象参数访问外部类成员,外部类访问不了内部类的成员。
(2)特性
1.内部类可定义在private,public,private位置
2,sizeof()计算外部类,不包括内部类
3.内部类可以直接访问外部类的staic成员,不需要外部类的对象/类名。
//内部类
class A {
public:
class B{
public:
void fun(A& a)
{
cout << a.h << endl;//通过对象参数访问成员
cout << k << endl;//可直接访问静态成员
}
private:
int a = 9;
};
private:
int h = 9;
static int k;
};
int A::k = 5;
int main()
{
A::B b;
A a;
b.fun(a);
cout << sizeof(a);//a的大小只有h,k不包括b
return 0;
}
五.匿名对象
(1)匿名对象的用处
匿名对象有时候比较方便使用,要用到的地方直接匿名对象,不用创造对象然后在调用成员。不过
由于匿名对象的生命周期短,如果对象要周期生效,不使用匿名对象。
//匿名对象 A()
class A {
public:
A(int k = 9)
:_k(k)
{
cout << "A(int k=9)" << endl;
}
~A()
{
cout << "~A()";
}
private:
int _k;
};
int main()
{
//匿名对象,只在这一行生效,过了这一行就会调用析构函数
A();//// 我们可以这么定义匿名对象,匿名对象的特点不用取名字
return 0;
}
六.拷贝对象时的一些优化
在传参和传返回值的过程中,一般编译器会做一些优化,减少对象的拷贝,这个在一些场景下还 是非常有用的。一般比较新的编译器都会优化
可以理解为编译器比较聪明,会对代码进行检查和判断。
class A { public: A(int a = 0) :_a(a) { cout << "A(int a)" << endl; } A(const A& aa) :_a(aa._a) { cout << "A(const A& aa)" << endl; } A& operator=(const A& aa) { cout << "A& operator=(const A& aa)" << endl; if (this != &aa) { _a = aa._a; } return *this; } ~A() { cout << "~A()" << endl; } private: int _a; }; void f1(A aa) {} A f2() { A aa; return aa; } int main() { // 传值传参 A aa1; f1(aa1); cout << endl; // 传值返回 f2(); cout << endl; // 隐式类型,连续构造+拷贝构造->优化为直接构造 f1(1); // 一个表达式中,连续构造+拷贝构造->优化为一个构造 f1(A(2)); cout << endl; // 一个表达式中,连续拷贝构造+拷贝构造->优化一个拷贝构造 A aa2 = f2(); cout << endl; // 一个表达式中,连续拷贝构造+赋值重载->无法优化 aa1 = f2(); cout << endl; return 0; }
本文详细探讨了C++中的构造函数、初始化列表、static成员、友元、内部类和匿名对象的概念,以及拷贝对象时的编译器优化,强调了封装的重要性。

被折叠的 条评论
为什么被折叠?



