C++ 类和对象下
目录
1.再谈构造函数
2.初始化列表
2.1定义
2.2分析代码
3.隐式类型转换
3.1单参数（C++98）
3.2双参数（C++11）
3.3explicit关键字
4.Static成员
4.1特性
5.友元
5.1友元函数
5.2友元类
6.内部类（很少用）
7.匿名对象
7.1特性
8.编译器的优化
8.1传参优化
8.2返回优化
1.再谈构造函数
class C
{
public:
C(int grade)//这个不是默认构造
:_grade(grade)
{}
private:
int _grade;
};
class A
{
public:
A(int grade)
:_grade(grade)
, _a(3)
, _b(_grade)
, _c(99)
{
cout << "A(int grade)" << endl;
}
A(const A& x)//这个const注意
:_grade(x._grade)
, _a(x._a)
, _b(x._b)
, _c(x._c)
{
cout << "A(const A& x)" << endl;
}
private:
int _grade;
const int _a;
int& _b = _grade;
//C _c(10);
C _c = 10;
};
int main()
{
A a(10);
return 0;
}2.初始化列表
为了解决：const ，引用类型没有默认构造可以用，自定义类型可能会没有默认构造可以用
2.1定义
①初始化列表是成员变量定义的地方，在构造函数(拷贝构造也是构造)中使用，所有的成员都会走初始化列表
②定义顺序为成员变量的声明顺序
③在初始化列表的成员就在初始化列表里定义，没有的再定义成缺省值
④初始化列表只能出现一次成员，不然会报错
其实说来说去还是对这句话的理解：
如果这个成员没有在初始化列表：内置类型不做处理（除非给了缺省值），对自定义类型调用它的默认构造
2.2分析代码
C类是没有写默认构造
错误①
我刚开始出现这个问题，这个C类要在A类上面定义
错误②
C _c(10)，会有语法错误，C _c; 这样也不行，因为C类没有默认构造,什么事默认构造:类和对象上是引入了初始化列表的一个原因，因为没法初始化没有默认构造的自定义类型
3.隐式类型转换
3.1单参数（C++98）
对于C _c = 10; 来说，这里有个隐式类型的转换，对于单个参数的构造函数，支持隐式类型转换
int main()
{
A a1(10); //1
A a2 = 2; //2
A& a3 = 10; //3
const A& a4 = 10; //4
return 0;
}①单参数的构造函数
②先构造函数初始化临时对象，在执行拷贝构造 优化为构造
③临时对象具有常性,编译错误
④const具有常性，这里引用了临时对象，所以编译器没法优化（新一点的编译器会优化掉）
3.2双参数（C++11）
没有区别，两个参数用{}，大括号括起来就行；例：A a = { 2, 2 };
3.3explicit关键字
explicit A(int grade)在构造函数的前面加上explicit就行，这样就会禁止隐式类型的转换
4.Static成员
比如说我们要统计创建对象的次数
class A
{
public:
A(int grade)
://...
{
//...
count++;
}
private:
int _grade;
const int _a;
int& _b = _grade;
C _c = 10;
static int count;
};
int A::count = 0;//类外定义,可以不初始化我就把关键部分写下,这样会出现一个问题，我们必须要有对象才能知道创建过的对象的个数。
例子如下
void func()
{
A a[10];
}
int main()
{
func();
A a;
cout<< a.count - 1<我们还要在类内加一个默认构造，直接用全缺省的默认构造 ：A(int grade = 0)
其实很麻烦①在类内加一个GetCount()的函数，为了知道个数②还有在定义一个对象③GetCount还要减一
所以引入新的办法：静态函数
样例如下
通过类或者对象直接读取count（private修饰的话，不能读取）所以通过静态成员函数
class A
{
public:
static int GetCount()
{
return count;
}
private:
static int count;
};
int A::count = 0;
int main()
{
A::GetCount;
A a;
a.GetCount();
}4.1特性
①静态成员函数就是为了静态成员变量而生的
②静态成员函数不能访问（读写）非静态成员变量（因为没有隐藏的this指针）
③静态成员属于所有的对象，属于整个类
④同样有访问权限，不能被const修饰
5.友元
增加耦合度，破坏封装，不建议多用
5.1友元函数
在类内声明后，友元函数可以直接访问类的私有成员
class A
{
friend void func();
public:
private:
}
void func()
{
A a;
cout << a._grade;
}①友元声明可以放在类里面的任何地方
②友元函数不能用const修饰
③友元声明可以放在多个类里
5.2友元类
class A
{
friend class B;
public:
private:
int _grade;
};
class B
{
public:
int func(A a)
{
return a._grade;
}
private:
};①友元关系是单项的
②友元关系不能传递
总结：你看 类A 里面有个B ，就好比A给了B一把钥匙，那么B就可以访问它，而B，没有给A，就是这么合理
6.内部类（很少用）
class A
{
public:
class B
{
public:
int func(A a)
{
count++;
a._grade++;
return a._grade;
//_grade++; ×
}
private:
};
private:
int _grade;
static int count;
//...
};
int A::count = 0;①内部类受访问限定符的限制
②非静态成员必须与特定的对象相对，（用对象，例： a._grade++, 直接_grade找不到）
③sizeof的大小是外部类，和内部类无关
总结：内部类是外部类的友元，内部类由外部类的钥匙
7.匿名对象
7.1特性
class A
{
public:
static int GetCount()
{
return count;
}
void func()
{
}
private:
int _grade;
const int _a;
int& _b = _grade;
C _c = 10;
static int count;
};
int A::count = 0;
int main()
{
A().func();
A().GetCount();
}
①生命周期只在这一行
②如果func是private，不能访问
③创建匿名对象，会去调用拷贝构造
④匿名对象具有常性
8.编译器的优化
8.1传参优化
void func1(A a)
{
}
void func2(A& a)
{
}
void func3(const A& a)
{
}
int main()
{
A a = 1; //1 构造+拷贝->构造
func1(a); //2 拷贝
func1(1); //3 构造+拷贝->构造
func1(A()); //4 构造+拷贝->构造
func2(a); //5 直接传
func2(1); //6 临时对象具有常性，也就是临时对象不能改变，计算const修饰
func2(A()); //7 同6
func3(a); //8 直接传
func3(1); //9 构造+拷贝
func3(A()); //10 构造+拷贝
return 0;
}9和10不能优化，这个临时对象必须有，不然怎么引用
总结：接收返回值，尽量拷贝构造接收，不要赋值接收
8.2返回优化
A func1()
{
A a;
return a;
}
A func2()
{
return A();
}
int main()
{
func1();//构造+拷贝（拷贝给临时对象）
A a1 = func1();//构造+拷贝+拷贝->构造+拷贝
func2();//构造+拷贝->构造//你这么想他构造出来的是临时对象，拷贝构造出来的也是临时对象
A a2 = func2();//构造+拷贝+拷贝->构造
}总结：函数返回对象时，尽量返回匿名对象
注：新的编译器调试不出效果，它优化的厉害