C++ 类使用
一、C++ 类使用
1、类成员的初始化顺序
下面学习下，C++类成员的初始化顺序，例如：
class A
{
private:
int n1;
int n2;
public:
A():n2(0),n1(n2+2){}
void Print(){
cout << "n1:" << n1 << ", n2: " << n2 <<endl;
}
};
int main()
{
A a;
a.Print(); // 输出结果 n1:46 , n2:0
return 0;
}
上面的程序输出时，n1的值是一个随机值，并不是符合预期的值，n2对应的值是0符合预期。下面总结下成员变量的初始化顺序
- 成员变量使用初始化列表初始化时，成员变量的初始化顺序与初始化列表的顺序无关，只与定义成员变量的顺序有关。因为成员变量的初始化次序是根据变量在内存中次序进行初始化，而内存中的排列顺序早在编译期就根据变量的定义次序决定了。
- 如果不使用初始化列表初始化，在构造函数内初始化时，此时与成员变量在构造函数中的位置有关。
- 类中const成员常量必须在构造函数初始化列表中初始化。
- 类中引用类型必须在构造函数初始化列表中初始化。
- 类中static成员变量，必须在类外初始化。
2、构造函数与析构函数主动调用
2.1、构造函数主动调用
一般情况下在创建对象时，构造函数由编译器来调用。但是可以主动调用构造函数来创建匿名对象，例如：
class Person{
private:
int age;
public:
Person(int age) {
this->age = age;
}
void Display() const {
cout << "age = " << age << endl;
}
};
void test(const Person &r) {
r.Display();
}
int main()
{
test(Person(20)); // 主动调用构造函数创建匿名对象
return 0;
}
2.2、主动调用析构函数
析构函数可以主动调用，但是C++规范一般不推荐这么做，主动调用析构函数可能会导致内存重复释放，例如：
class Person{
private:
char *name;
public:
Person() {
this->name = new char[10];
}
~Person() {
cout << "begin to delete" << endl;
delete [] name;
}
};
int main()
{
Person obj;
obj.~Person();
return 0;
}
输出结果
begin to delete
begin to delete
Process returned 0 (0x0) execution time : 0.006 s
Press any key to continue.
3、类的静态成员变量
3.1、声明类的静态成员变量
在类里面声明静态成员变量，例如：
class Base
{
public:
Base(int val = 0):m_x(val){
cout << "Base constructor" << endl;
}
public:
static int m_x;
};
类的静态成员变量存放在全局数据区，它的生命周期和普通的静态变量一样，程序运行时进行分配内存和初始化，程序结束时则被释放。静态成员变量属于类，多个类对象之间共享这个静态成员变量。注意：静态成员仍然遵循public，private，protected访问准则
3.2、类静态成员变量初始化
静态数据成员不能在类中初始化，一般在类外（在.cpp文件中，而不是在头文件中）和main()函数之前初始化，缺省时初始化为0。
class Base
{
public:
Base(int val = 0):m_x(val){
cout << "Base constructor" << endl;
}
public:
static int m_x;
};
int Base::m_x = 20;
注意：只有在类中声明静态变量才加static关键字，如果是在类外初始化静态成员变量不能加static关键字，不然会报错。
3.3、访问类静态成员变量
访问类的静态成员变量一般使用下面两种方法：类名::变量名、类对象.变量名、（指向类对象的指针）->静态成员变量也可以在类的成员函数（静态或非静态成员函数）中直接访问静态成员变量。例如：
class Base
{
public:
static int m_x;
void Display() {
cout << "m_x = " << m_x << endl; // 类的非静态成员函数，直接访问静态成员变量
}
};
int Base::m_x = 20;
int main()
{
Base obj;
Base *p = &obj;
cout << "Base::m_x = " << Base::m_x << endl;
cout << "Base::m_x = " << obj.m_x << endl;
cout << "Base::m_x = " << p->m_x << endl;
obj.Display();
return 0;
}
3.4、类const static成员变量
类的static数据成员，像普通数据成员一样，不能在类的定义体中初始化。相反，static数据成员通常在定义时才初始化。但是，const static数据成员就可以在类的定义体中进行初始化。同样，它可以用在任何需要常量表达式的地方，例如：指定数组成员daily_tbl的大小。
class Account{
private:
//const static常量在类体中进行初始化
const static period = 20;
double daily_tbl[period];
double amount;
public:
static double rate(){
return interestRate;
}
static void setRate(double newRate){
interestRate = newRate;
}
};
知识点一：类的静态成员变量，在使用之前必须要进行初始化，不然编译时会出错
下面的代码使用未初始化的静态成员变量，编译时报错，例如：
class Base
{
public:
static int m_x;
static void Display() {
cout << "m_x = " << m_x << endl;
}
};
int main()
{
Base obj;
Base *p = &obj;
cout << "Base::m_x = " << Base::m_x << endl;
cout << "Base::m_x = " << obj.m_x << endl;
cout << "Base::m_x = " << p->m_x << endl;
obj.Display();
return 0;
}
4、类的静态成员函数
4.1、声明类的静态成员函数
类静态成员函数的声明与静态成员变量的声明类似，例如：
class Base
{
public:
static int m_x;
static void Display() {
cout << "m_x = " << m_x << endl;
}
};
4.2、调用类的静态成员函数
类的静态成员函数与非静态成员函数都可以直接调用静态成员函数，例如：
class Base
{
public:
void Ouput() {
Display(); // 1、非静态成员函数调用静态成员函数
}
static void Show() {
Display(); // 2、静态成员函数调用静态成员函数
}
public:
static int m_x;
static void Display() {
cout << "m_x = " << m_x << endl;
}
};
下面对类的静态成员变量和成员函数作个总结，如下：
- 非静态成员函数可以直接调用静态成员函数
- 非静态成员函数可以直接访问静态数据成员
- 静态成员函数只能调用静态成员函数，不能调用非静态成员函数
- 静态成员函数只能直接访问静态数据成员，不能直接访问非静态数据成员
静态成员函数不能直接访问类的非静态成员，但是可以通过外部传入对象指针来间接访问类的非静态成员，例如：
class CExample
{
public:
static void Func(CExample *pobj);
private:
int m_age;
};
void CExample::Func(CExample *pobj)
{
CExample *pThis = pobj;
pThis->m_age = 100; // 通过传进来的对象指针，在静态成员函数中间接访问非静态数据成员
}
int main()
{
CExample obj;
CExample::Func(&obj);
return 0;
}
4.3、静态成员函数与非静态成员函数的区别
编译器在编译一个普通成员函数时，会隐式地增加一个形参 this，并把当前对象的地址赋值给 this，所以普通成员函数只能在创建对象后通过对象来调用，因为它需要当前对象的地址。而静态成员函数可以通过类来直接调用，编译器不会为它增加形参 this，它不需要当前对象的地址，所以不管有没有创建对象，都可以调用静态成员函数。静态成员函数与普通成员函数的根本区别在于：普通成员函数有 this 指针，可以访问类中的任意成员；而静态成员函数没有 this 指针，只能访问静态成员（包括静态成员变量和静态成员函数）。
5、const类成员函数
5.1、常成员函数的定义
在函数声明的后面加上const，就定义了一个常量成员函数，例如：
class List{
private:
int length;
int weight;
public:
List(int l, int w){
length = l;
weight = w;
}
int getLength() const; //常成员函数
int getWeight(); //非常成员函数
};
注意：在类外定义常成员函数时，也要加上const关键字
int List::getLength() const{ //类外定义也要加上const关键字
return length;
}
如果在常量成员函数中修改对象的数据成员，编译时会出错
int List::getLength() const{
return length ++;
}
5.2、常成员函数的作用
const成员函数存在的意义在于它能被const常对象调用，而且常对象只能调用常成员函数。
const List list1(10, 10); //定义一个常对象
list1.getLength(); //常对象调用常量成员函数
常对象不能调用非常成员函数，不然在编译时会出错
const List list1(10, 10); //定义一个常对象
list1.getWeight(); //常对象调用非常成员函数,在编译时会出错
非常对象可以调用常成员函数
List list1(10, 10); //定义一个非常对象
list1.getLength(); //非常对象调用常成员函数
5.3、如何让一个const成员函数具有修改对象数据成员的能力
有些时候，如果必须要让const函数具有修改某个成员数据值的能力。比如一些内部的状态量，对外部用户无所谓，但是对整个对象的运行却大有用处。遇到这种问题，可以把一个成员数据定义为mutable（多变的），它表示这个成员变量可以被const成员函数修改却不违法，例如：
class List{
private:
mutable bool is_valid;
public:
void checkList() const{
if(is_valid){
is_valid = false;
} else {
is_valid = true;
}
}
};