C++ 类（第二章）

class Bar{
public:
	...
private:
	static Bar mem1;//正确
	Bar *mem2;//正确
	Bar mem3;//错误
>};

静态成员函数不与任何对象绑定，因此，不包含this指针，也不能被声明成const函数，所以静态成员函数只能访问静态成员变量和静态成员函数，非静态成员函数（普通成员函数、常成员函数）可以访问所有成员变量。静态成员函数可以在类内、也可以在类外定义。

#include 
#include 
using namespace std;

class Animal{
    private:
        static int total;
        string name;
    public:
        Animal(string c_in):name(c_in){
            total++;
        }
        static void show();
};

//静态成员变量必须在类外进行初始化
int Animal::total=0;
void Animal::show(){
    cout<<total<<endl;
}

int main(){
    Animal cat("cat");
    Animal dog("dog");
    Animal pig("pig");

    cat.show();
    dog.show();
    pig.show();
    Animal::show();

    return 0;
}

上面代码将show()定义为static，可以直接通过类访问。

• const成员变量声明时只需增加const关键字，初始化时只能使用初始值列表进行初始化。

• const成员函数声明时需要在头部结尾处加const，是int get() const; 而不是const int get(),第一个是常成员函数，只能读取任意一个成员变量但不能修改，第二个是返回一个int常量。const成员函数在声明和定义处都需要加const。

//常成员函数和变量
#include 
#include 
using namespace std;

class Animal{
private:
    string name;
    const string skin;
public:
    //skin只能通过初始值列表初始化
    Animal(string name, string skin):name(name),skin(skin){}
    //常成员函数只能读取属性
    void show() const;
};

void Animal::show() const{
    cout<<name<<"的毛色是"<<skin<<endl;
}

int main(){
    Animal cat("cat","red");
    cat.show();
}

const也可以声明对象，此时该对象被称为常对象，常对象只能访问常成员变量和常成员函数。

友元是一个特别有意思的东西，它是单向，也不能被传递，通过友元可以打破private、protected、public的访问限制。例如函数A是类B的友元函数，则A可以访问B的私有数据成员。友元通过friend关键字修饰。

//友元函数和友元类
#include 
#include 
using namespace std;

class Animal{
private:
    string name;
    const string skin;
public:
    //skin只能通过初始值列表初始化
    Animal(string name, string skin):name(name),skin(skin){}
    //常成员函数只能读取属性
    friend void show(Animal *animal) ;
};

//
void show(Animal *animal){
    cout<<animal->name<<"的毛色是"<<animal->skin<<endl;
}

int main(){
    Animal cat("cat","green");
    show(&cat);//通过友元函数访问Animal类的私有成员变量
}

需要注意的因为show()是全局函数，所以不包含this指针，需要通过传入指针进行调用。一个类的成员函数也可以作为另一个类的友元函数。

//友元类
#include 
#include 
using namespace std;

class Country;

class Car{
private:
    string name;
    string skin;
public:
    Car(string name, string skin):name(name),skin(skin){}
    void show(Country *city);
};

class Country{
private:
    string city;
public:
    friend void Car::show(Country *city);
    Country(string city):city(city){}
};

void Car::show(Country *city){
    cout<<name<<"产自"<<city->city<<"，颜色是"<<skin<<endl;
}


int main(){
    Country china("China");
    Car byd("byd","black");
    byd.show(&china);//通过Car的show问Country类的私有成员变量
}

整个类也可以被声明为友元，此时为友元类，该类的所有成员函数都是另一个类的友元函数，只要将friend void Car::show(Country *city);换为friend class Car;不过不建议这样做。

基本上类的知识都已经讲完了把，接下来可以讲讲类的内存方面的知识。