一、再谈构造函数
【构造函数体赋值】
1）初始化：一个变量或者一个对象在产生的时候就赋予一个值，属于伴随性质
2）赋值：在一个变量或者一个对象在产生之后的任意时刻赋予一个值，属于任意性质
class Date
{
public:
//构造函数
Date(int year = 2022, int month = 4, int day = 19)
{
_year = year;
_month = month;
_day = day;
_year = 2023;//构造函数体内允许对成员变量进行多次赋值
}
private:
int _year;
int _month;
int _day;
};虽然上述构造函数调用之后，对象中已经有了一个初始值，但是不能将其称为对对象中成员变量的初始化，构造函数体中的语句只能将其称为赋初值，而不能称作初始化。因为初始化只能初始化一次，而构造函数体内可以多次赋值。
1.1 初始化列表
初始化列表：以一个冒号开始，接着是一个以逗号分隔的数据成员列表，每个"成员变量"后面跟一个放在括号中的初始值或表达式。
【注意】
1. 每个成员变量在初始化列表中只能出现一次(初始化只能初始化一次)
2. 类中包含以下成员，必须放在初始化列表位置进行初始化：
2.1 引用成员变量
2.2 const成员变量
2.3 自定义类型成员(且该类没有默认构造函数时)
都不能先定义后初始化。
class MyQueue
{
public:
// Stack不具备默认构造。MyQueue也无法生成默认构造
// 初始化列表
// 初始化列表本质可以理解为每个对象中成员定义的地方
MyQueue(int n,int& rr)
:_push(n)
,_pop(n)
,_size(0)
,_x(1)
,_ref(rr)
{}
private:
// 声明
// 缺省值是给初始化列表使用的
int _size = 0;
// 必须在定义时初始化
Stack _push;
Stack _pop;
const int _x;//const int _x = 10;不要误理解这个地方只是声明！！！缺省值
int& _ref;
};
int main()
{
int xx = 10;
// 定义
MyQueue q1(10,xx);
return 0;
}它们在初始化列表内定义，并且必须在定义时就初始化，因此必须在初始化列表内初始化。
3.初始化列表，不管你写不写，每个成员变量都会先走一遍（可以自己调试一下）
3.1自定义类型的成员会调用默认构造(没有默认构造就编译报错)
3.2内置类型有缺省值用缺省值，没有的话，不确定看编译器，有的编译器会处理，有的不会处理
4.先走初始化列表 + 再走函数体(MyQueue内部{})
实践中:尽可能使用初始化列表初始化，不方便（就比如@地方），再使用函数体初始化
class MyQueue
{
public:
// @
MyQueue()
:_ptr((int*)malloc(40))
{
//所有的字节初始化为0
memset(_ptr, 0, 40);
}
private:
int* _ptr;
};5. 成员变量在类中声明次序就是其在初始化列表中的初始化顺序，与其在初始化列表中的先后次序无关
先走_a2，再走_a1
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();
}
先走_a1，再走_a2
class A
{
public:
A(int a)
:_a1(a)
,_a2(_a1)
{}
void Print() {
cout << _a1 << " " << _a2 << endl;
}
private:
int _a1;
int _a2;
};
int main() {
A aa(1);
aa.Print();
}
1.2 隐式类型转换
【单参数构造】
class A
{
public:
A(int a)
:_a(a)
{
cout << "A(int a)" << endl;
}
A(const A& a)
:_a(a._a)
{
cout << "A(const A& a)" << endl;
}
private:
int _a;
};在main函数中
// 构造
A aa1(1);
// 拷贝构造
A aa2 = aa1;下面就是隐式类型转换，内置类型转换为自定义类型，3构造一个A的临时对象，在用这个临时对象拷贝构造aa3，编译器遇到连续构造+拷贝构造--->优化为直接构造。隐式类型转换跟我在C++入门当中的常引用那一篇文章中很类似。
A aa3 = 3;raa引用的是类型转换中用3构造的临时变量，只发生3构造一个A的临时对象
const A& raa = 3;
如果不想发生隐式类型转换------>explicit修饰构造函数 ,禁止类型转换---explicit去掉之后，代码可以通过编译
如果在构造函数中添加explicit修饰
【多参数构造】
class A
{
public:
A(int a1, int a2)
:_a(0)
,_a1(a1)
,_a2(a2)
{}
A(const A& a)
:_a(a._a)
,_a1(a._a1)
,_a2(a._a2)
{}
private:
int _a;
int _a1;
int _a2;
};
main函数
A aaa1(1, 2);
A aaa2 = { 1,2 };
const A& aaa3 = {1,2};与单参数区别就是需要用 { }括起来
class Stack
{
public:
void Push(const A& aa)
{
//...
}
//...
};main函数
Stack st;
st.Push({ 1,2 });{1, 2}先传给aa ，再构造临时变量，最后调用Push
二、static成员
我在C语言那里提到过static修饰变量，函数的的生命周期以及内部属性外部链接属性
声明为static的类成员称为类的静态成员，用static修饰的成员变量，称之为静态成员变量；用static修饰的成员函数，称之为静态成员函数。静态成员变量一定要在类外进行初始化。
对象中只包括成员变量，不包括静态成员变量
在某类中，例如：
private:
int _a1;
int _a2;
static int _scount;这个对象大小是8个字节
那在思考
静态成员变量能给缺省值吗？
不能 ---- 缺省值是给初始化列表使用而静态成员变量在静态区，不走初始化列表
那如何初始化静态成员变量呢？
静态成员变量在类里面声明，类外面定义
类里面静态成员变量-----类似于全局变量--->为什么类似于全局变量？---->全局变量与静态成员变量都在静态区，两者在.h中同时声明定义，被多个.cpp文件包含都会发生重定义，他们的解决措施一样就是在.h声明，只在一个.cpp中定义。
2.1 特性
static修饰成员变量
1. 静态数据成员属于整个类，而不属于某个对象，所有对象共享静态数据成员
2. 静态成员变量必须在类外定义，定义时不添加static关键字，类中只是声明
3. 类静态成员即可用 类名::静态成员 或者 对象.静态成员 来访问
4. 静态成员也是类的成员，受public、protected、private 访问限定符的限制
class A
{
public:
static int _a;
private:
static int _b;
};
//定义
int A::_a = 1; // 2特性
int A::_b = 1;
int main()
{
A aa1;
cout << A::_a << endl;// 3
cout << aa1._a << endl;// 3
A aa2;
aa2._a = 2;// 1
cout << aa1._a << endl;
cout << aa2._a << endl;// 1
return 0;
}static修饰成员函数
1. 静态成员函数没有隐藏的this指针，不能访问任何非静态成员，只能访问静态成员
2. 非static成员函数既可以访问static数据成员，也可以访问非static数据成员。static成员函数只能访问satic成员
class A
{
public:
static int _a;
static int GetA()
{
//_c = 1;//不能访问
return _b; // 1
}
void func()
{
_c = 1;
_b++; // 2
}
private:
static int _b;
int _c;
};
//定义
int A::_a = 1;
int A::_b = 1;
int main()
{
A aa1;
cout << A::_a << endl;
cout << aa1._a << endl;
A aa2;
aa2._a = 2;
cout << aa1._a << endl;
cout << aa2._a << endl;
return 0;
}我们在修改一下，验证一下 static修饰成员变量特性，4
class A
{
public:
static int _a;
static int GetA()
{
//_c = 1;
return _b;
}
void func()
{
_b++;
}
private:
static int _b;
};
//定义
int A::_a = 1;
int A::_b = 100;
int main()
{
A aa2;
cout << aa2.GetA() << endl;
return 0;
}上面的代码解释了， 静态成员也受访问限定符的限制，A类中public static int _a可以通过类名::静态成员 或者 对象.静态成员 来访问，而私有的只能调用static成员函数
三、友元
友元提供了一种突破封装的方式，有时提供了便利。但是友元会增加耦合度，破坏了封装，所以友元不宜多用。
3.1 友元函数
友元函数可以直接访问类的私有成员，它是定义在类外部的普通函数，不属于任何类，但需要在类的内部声明，声明时需要加friend关键字。
友元函数可访问类的私有和保护成员，但不是类的成员函数
友元函数不能用const修饰
友元函数可以在类定义的任何地方声明，不受类访问限定符限制
一个函数可以是多个类的友元函数
友元函数的调用与普通函数的调用原理相同
class Date
{
friend ostream& operator<<(ostream& _cout, const 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;
}3.2 友元类
友元类的所有成员函数都可以是另一个类的友元函数，都可以访问另一个类中的非公有成员。
class A
{
//声明 B是A的友元
// B可以访问A的私有，但是A不能访问B的私有
friend class B;
private:
int _a;
int _b;
};
class B
{
void Print()
{
_bb._a = _c;
_bb._b = _d;
}
private:
int _c;
int _d;
A _bb;
};四、内部类
概念：如果一个类定义在另一个类的内部，这个内部类就叫做内部类。内部类是一个独立的类，它不属于外部类，更不能通过外部类的对象去访问内部类的成员。外部类对内部类没有任何优越的访问权限。
class A
{
private:
static int k;
int h;
public:
class B // B天生就是A的友元
{
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改为私有，就不能访问内部类
b.foo(A());
return 0;
}五、匿名对象
class A
{
public:
A(int a = 0)
:_a(a)
{
cout << "A(int a = 0)" << endl;
}
~A()
{
cout << "~A()" << endl;
}
private:
int _a;
};
int main()
{
//有名对象，生命周期当前作用域
A aa1;
cout << endl;
//匿名对象，生命周期只在当前一行
A();//匿名对象
//A(2);
cout << endl;
//匿名对象具有常性
const A& aa2 = A();
return 0;
}
匿名对象能匿名对象被视为常量，这意味着不能通过它们修改成员变量的值。
350
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
