咸鱼的翻身计划6：c++中的类和对象，对象特性

1.初始化列表

C++除了可以用构造函数初始化，还有一种方法，就是初始化列表，

语法：构造函数（）：属性1（值1），属性（值2）…{ }

感觉算是构造函数的一种延伸用法。

2.静态成员

就是在成员变量和成员函数前加上关键字 static ，对应的成员就称之为静态成员。

静态成员变量：

(1)所有对象共享同一份数据，比如实例化s1,s2，如果s1的静态变量值改变，s2的也会改变。

(2)类内声明，类外定义，必须得有一个初始值，否则没法用，而且不能在类内定义。

(3)在编译阶段分配内存

#include<iostream>
using namespace std;


calss Student{
public:
    

    int m_Age;    //普通成员变量
    
    static int m_Height;    //静态成员变量，类内声明

    

};

int Student::m_Heiight = 100;    //类外初始化，Student:: 表明是初始化Student类里面的静态变量


int main()
{
//除了常规的先创建一个对象来访问成员变量外，还可以通过类名访问静态变量
    Student s1;
    s1.m_Height=200;    //常规访问

    Student::m_Height=1000;    //通过类名访问


    return 0;
}
    

静态成员函数：
(1)所有对象共享一个函数

(2)静态成员函数只能访问静态成员变量

#include<iostream>
using namespace std;


calss Student{
public:
    

    void test()
    {
        //m_Age=0;    //写这行会报错，静态成员函数只能访问静态成员变量
        
        m_Height=0;
    }

    int m_Age;    //普通成员变量
    
    static int m_Height;    //静态成员变量，类内声明

    

};

int Student::m_Heiight = 100;    //类外初始化，Student:: 表明是初始化Student类里面的静态变量


int main()
{
//静态成员函数两种访问方式，跟静态成员变量一样。
    Student s1;
    s1.test();

    Student::test();

    return 0;
}
    

3.成员变量和成员函数分开存储

每个非静态成员函数只会诞生一份函数实例，也就是说多个同类型的对象会共用同一块代码。就跟全局函数差不多的性质，不过成员函数只有类创建的对象可以用，所以说创建一个对象，只有非静态成员变量，是这个对象独有的，其他像静态成员对象，成员函数，静态成员函数，每个对象都可以共享。

4.this指针

c++提供的特殊的对象指针，也就是对象类型的指针，哪个对象被访问，this就指向哪个对象，比如你定义一个Student类，this指针就相当于Student *this 跟C中的结构体指针一个意思，然后创建一个对象 Student  s1; 如果访问s1， 则此时this就指向s1。除了用 s1.成员变量用 还可以在类内用 this->成员变量 来访问对象成员。在类内使用，无需定义。（如果指针的知识不太了解可以看看这个http://t.csdn.cn/gCH6h）

this作用

当形参和成员变量同名时，可以用this指针来区分。

在类的非静态成员函数中返回对象的本身，可以用return *this；

#include<iostream>
using namespace std;

class Student{
public:
    int age;    //成员变量

//this指针区分同名成员变量
    Student(int age)    //构造函数
    {
        //还像以前一样直接 age = age;是不行滴，不知道哪一个是成员变量，哪个是形参，此时用this区分
        
        this->age = age;    
    }

//this指针返回对象本身
    Student& add(Student &s)    //实现Student类的对象的age加上另一个的age。
    {
        this->age += s.age;
        return *this;    //返回这个对象，因为时返回本身，所以函数前面的返回值类型是 Studet&
    }
};


int main()
{
    //创建两个对象
    Student s1,s2;

    //初始化两个这对象
    s1.age = 10;
    s2.age = 20;

    s2.add(s1);    //此时s2的值为30；
    
//因为返回的是s2,还Student类的对象，所以可以连续调用
    s2.add(s1).add(s1).add(s1);    //这个叫链式编程思想，cout<<就是这原理。

    return 0;
}
    

5.空指针访问成员函数

比如一个函数类内定义，一般只能通过类的对象才能带调用，但你又不想再写一个一样的全局函数这时候就可以用空指针来访问，但要注意不能访问使用了this指针的成员函数，因为空指针调用的函数，this指针不指向某个对象，而是指向空，那么如果到函数访问 this->age，是不合法的。

#include<iostream>
using namespace std;

class Student{
public:
    int age;    //成员变量
    
    void add(int a,int b,int &c)    //对c，也就是第三个数输入的数进行操作，加上前两个数。
    {
        c = a+b;
        //age = c;如果加上这行再用空指针调用函数就会报错，这行代码用到了this指针，    
        //这行代码相当于是 this->age = c;
    }

};


int main()
{
    Student *p = NULL;    //定义一个类型是Student*的指针指向空，也就是不存入地址的指针变量
    int a=10,b=20,c=30;

    //空指针调用成员函数
    p->add(a,b,c);    //此时如果输出c的值应为60.
    
    return 0;
}
    

6.const修饰成员函数

const修饰的成员函数从称之为常函数，是不能修改成员属性的（也就是成员变量，都一个意思）但是可以修改前面加了mutable关键字的成员属性。

常对象，声明对象前要加上const，常对象只能调用常函数

#include<iostream>
using namespace std;

class Student{
public:
    int age;    //成员变量
    mutable int yz;
    
    void test01() const    //这就叫const修饰的常函数
    {
        yz = -100;    //修改了一下mutable修饰的成员属性
        cout<<"你是一个吃藕八怪"<<endl;
    }

    void test02()    //普通的成员函数
    {
        age = 10;    //修改了一下成员属性，如果加const修饰这个函数就是不对的
    }
};


int main()
{
    Student s1;    //创建一个普通对象

    s1.test01();    //调用常函数

    const Student s2;    //创建一个常对象

    s2.teat01();

    //s2.test02(); 这行代码是不对的，常兑现只能调用常函数   

    return 0;
}