C++中类的易忽略知识点（初级）

1.类的基本思想是数据抽象和封装。数据抽象是一种依赖于接口和实现分离的编程技术。类的接口包括用户所能执行的操作；类的实现则包括类的数据成员、负责接口实现的函数体以及定义类所需要的各种私有函数。封装实现了类的接口和实现的分离。封装后的类隐藏了它的实现细节，也就是说，类的用户只能使用接口而无法访问实现部分。

2.常量成员函数（只针对成员函数），作用是修改隐式this指针的类型。因为在默认情况下，this指针的类型是指向类类型非常量版本的常量指针（this指针总是指向某个对象，不允许改变this指针中保存的地址），这意味着在默认情况下不能把this绑定到一个常量对象上，但是this是隐式的，去哪将这个this声明为指向常量的指针就成为一个问题。C++通过把const关键字放在成员函数的参数列表之后，用来并表示隐式的this指针是一个指向常量的指针。这个成员函数就称为常量成员函数。构造函数是不能被声明为const的。

 

class A
{
public:
	int prince() const
	{
		return pri;//return this->pri;this所指的就是对象a
	}
	int pri;
}; 
int main() 
{ 
	A a; 
	a.prince();
	system("pause"); 
	return 0;
}

 

注意：即使pri定义在成员函数prince()之后，prince()函数还是能使用pri。这是因为编译器分两步处理类：首先编译成员的声明，然后才轮到成员函数体（如果有的话）。因此，成员函数体可以随意使用类中的其它成员而无须在意这些成员出现的次序。

 

3.默认情况下，拷贝类的对象就是拷贝对象的数据成员。  IO类（输入、输出类）属于不能被拷贝的类型，所以只能通过引用的方式来传递他们。

 

4.内联函数可以在程序中多次定义，一般函数不可以。但是多个定义必须完全一致，所以内联函数一般应该定义在头文件中。

 

5.类中的可变数据成员。有时，我们希望能够修改类的某个数据成员，即使实在一个const成员函数内。可以通过在变量的声明中加入mutable关键字做到。

class A
{
public:
	mutable int count=0;
	void prince() const//即使在常量成员函数内，count的值也会变化
	{
		++count;//count用来记录成员函数prince()被调用的次数
	}
};

 

6.类内初始值：创建对象时，类内初始值将用于初始化数据成员，没有初始值的成员将被默认初始化。

当我们提供一个类内初始值时，必须以=或者{}来表示。

 

class A
{
private:
	 int a = 8;//类内初始值
	 int b{6};//类内初始值
	 int c;//默认初始化
};

 

注意：如果类包括有内置类型或者复合类型的成员，则只有当这些成员全部被赋予了类内的初始值时，这个类才适合于使用合成的默认构造函数（编译器在我们未提供构造函数的情况下，隐式生成的）。

 

7.类的声明

<1>对于一个类来说，在我们创建它的对象之前该类必须被定义过，而不能仅仅被声明。否则，编译器无法了解这样的对象需要多少存储空间。

<2>类只要在定义之后，就可以用引用或指针访问其成员。

<3>一个类的成员类型不能是该类自己。因为只有当类全部完成之后类才算被定义，才能知道存储数据成员需要多少空间。

 

8.友元函数

<1>当把一个成员函数声明成友元时，必须明确该成员函数属于哪个类。而且，友元关系是不存在传递性的。

class B
{
public:
	void fun();
};
class A
{
	friend void B::fun();
};

注意：下面的方式是错误的，此时编译器提示使用了未声明的类型B

class B;
class A
{
	friend void B::fun();
};
class B
{
public:
	void fun();
};

<2>对于类和非成员函数的声明则不是必须在它们的友元声明之前。

class A
{
	friend class B;
};
class B
{
public:
	void fun();
};

<3>如果类的成员函数想要使用友元函数，必须要在类的外部提供相应的声明从而使得函数可见。

class A
{
	friend void fun() {}
	void print();
	void gun()
	 {
		return fun();//错误，找不到“fun”。说明即使成员函数在类内使用友元函数也不行。
          }
};
void A::print()
{
	return fun();//错误，找不到“fun”
}

正确的做法是使用之前声明

 

class A
{
	friend void fun() {}
	void print();
};
void fun();
void A::print()
{
	return fun();
}

 

9.名字查找与类的作用域

<1>C++中类的定义分两步处理：首先，编译成员的声明。直到类全部可见后才编译函数体。

<2>一定要注意，上述两阶段的处理方式只适用于成员函数中使用的名字。声明中使用的名字，包括返回类型或者参数列表中使用的名字，都必须在使用前确保可见。

<3>对于成员函数定义内的名字的查找

首先，在成员函数内查找该名字的声明。只有在函数使用之前出现的声明才被考虑。

如果在成员函数内没有找到，则在类内继续查找，这时类的所有成员都可以被考虑。

如果还没找到，就要考虑类定义之前的全局作用域中的声明以及成员函数定义之前的全局作用域中的声明。

10.构造函数初始值列表

 <1> 先看一个平时未注意到的区别，引用必须被初始化。

class A
{
private:
	int &r1;//没有报错，但是只能通过构造函数初始值的方式初始化
};

int main()
{
	int &r2;//错误，引用必须被初始化
	system("pause");
	return 0;
}

建议：使用构造函数初始值。

 <2>成员初始化的顺序是依据它们在类定义中出现的顺序，与初始值列表中初始值的前后位置关系没有关系。

class A
{
	int i;
	int j;
public:
	A(int a, int b) :j(b), i(a) {}//先初始化i再初始化j
};

11.隐式的类类型转换

只适用于构造函数只接受一个形参

class A
{
public:
	A(string s) :s1(s) {}
	void fun(const A &) {}
private:
	string s1="ab";
};
int main()
{
	A a{"abc"};
	string s2 = "qwe";
	a.fun(s2);//编译器用给定的s2创建了一个A类的对象,这个临时的对象被传递给fun()函数
	system("pause");
	return 0;
}

而且只允许一步类类型转换，也就是下面写法是错误的

a.fun("qwe");//错误，两步

此外，如果想要抑制上述的隐式的类类型转换，可以通过将构造函数声明为explict加以阻止。

 

12.类的静态成员，适用场景：有的时候需要它的一些成员与类本身直接相关，而不是与类的各个对象保持关联。

<1>通过在成员的声明之前加上关键字static使得其与类关联在一起。类的静态成员函数不与任何对象绑定在一起，它们不包含this指针。因此，静态成员函数就不能被声明成    const，因为const在成员函数中是用来修饰this指针的。

<2>和普通成员函数一样，既可以在类的内部也可以在类的外部定义静态成员函数。注意：当在类的外部定义静态成员时，不能重复static关键字，该关键字只能出现在类内      部的声明语句。

<3>因为静态数据成员不属于类的任何一个对象，所以它们并不是在创建类的对象时被定义的。也就是说，不是由类的构造函数初始化的。而且，一般来说，不能在类的内部     初始化静态成员（如果静态成员用constexpr修饰的话，则可以在类内提供初始值。即使这样，也应该在类的外部定义一下该成员），且一个静态数据成员只能定义一次。  

<4>静态数据成员可以是不完全类型（比如说类A，在声明之后，定义之前就属于不完全类型），非静态数据成员只能声明成它所属的指针或引用。

class A
{
	A a;//错误
	static A b;//正确
	A *c;//正确
	A &d;//正确
};

<5>静态成员和普通成员的另外一个区别是可以使用静态成员作为默认实参，而非静态数据成员不能作为默认实参，因为它的值就是属于对象的一部分，这样就无法真正提供一个对象以便从中获取成员的值。