this指针 & const & static

this

this指针表示类中的当前对象，在调用函数时，首先会将对象的地址传给this指针。对象主要是通过私有数据成员进行区分来判定。公有函数为所有对象所使用，且不占内存空间。

#

#include<iostream>
using namespace std;

class Test
{
public:
    Test(int d=0):data(d)
    {}
    //void fun(Test * const this)
    void fun()
    {
        data = 100;
    }
    //void fun(const Test * const this)
    void fun()const
    {
        //data =100;
    }
    ~Test()
    {}
private:
    int data;

};

void main()
{
    Test t(10);
    Test t2;
    t.fun();
    t2.fun();
}

声明：一个成员函数声明三点在逻辑上互不干扰的事情

1、该函数可以访问类中的私有成员
2、该函数属于类的作用域
3、该函数必须由一个类的对象去激活(对象的类部有一个this指针)

#

1、友缘函数，可以满足第一条

2、静态函数可以满足前两条，静态函数没有this指针

static

特点

1、 类的静态成员，属于类中所用对象所共享的，不属于某一个对象，因此没有this指针，并且只在公共内存 中 保存了一份。
2、 静态成员必须在类外声明：返回值 类名::静态成员=0；
3、访问方式：cout<<类名::静态成员<<endl;

#include<iostream>
using namespace std;
//声明公共类和函数
class Test;
void show(Test &other);
class Test
{
    friend void show(Test &other);
public:
    //static 成员不属于对象，属于一个类 为所用对象所共享
    //Test(int d,int c):data(d),count(c)
    //构造对象时，count++
    Test(int d=0):data(d)
    {
        count++;
    }
    //析构对象时count--
    ~Test()
    {
        count--;
    }
private:
    int data;
    static int count;//object number

};

int Test::count=0;
//将show()声明为Test类的友缘类，则可以访问该类的私有成员。
void show(Test &other)
{
    cout<<"data="<<other.data<<endl;
    //cout<<"Test number"<<other.count<<endl;
    cout<<"object number="<<Test.count<<endl;
}
void main()
{
    Test t(10);
    Test t1;
    show(t);
}

void fun() & static void fun()

1、普通成员函数,可以访问静态成员函数，也可以访问普通成员函数。
2、静态成员函数不能访问普通成员函数，只能访问静态成员函数。
原因：在类中，静态成员和静态方法中都没有this指针！！
类中的静态方法和静态成员没有this指针。普通方法中，void fun(Test * const this) 提供了this指针，静态方法中 static void fun()没有使用this,则普通方法调用静态方法可以;然而静态方法不能给普通方法传递this 指针 因此静态方法不能调用普通方法。

#

#include<iostream>
using namespace std;
class Test
{
public:
    Test(int d=0):data(d)
    {
        count++;
    }
    ~Test()
    {
        count--;
    }
public:
    //void print(Test * const this)

    /* void print()
    {
        cout<<this->data<<endl;
        cout<<Test::count<<endl;
    }
    */
    //静态方法没有this指针，不能访问类的非静态成员
     static void print()
     {
         //count<<this->data<<endl;
         cout<<Test::count<<endl;
         show();
     }
     void show()
     {
         print();
     }
private:
    int data;
    static int count;

};
//静态成员函数在类外初始化，静态成员函数不属于某一个类
int Test::count=0;
void main()
{
    Test t(10);
    //print(&t)
    t.print();
}

把*当成分水岭，然后进行判断哪个不变

int const *p;//const修饰P指向的值
const int *p;//与上面相同
int * const p;//修饰P的指向
const int * const p;//p的指向和p的指向的值

#

#include<iostream>
using namespace std;
void main()
{
    int a=10;
    int b=20;
    //int const *p=&a;
    //*p=100;
    int const *p=&b;
    cout<<*p<<endl;
    int * const q=&b;
    *q=100;
    cout<<b<<endl;
    int const * const pi =&a;
    cout<<a<<endl;
}   

const

const和#define为常量，二者区别：

1、const常量会进入程序的调试，通过编译器判断数据类型得到相应值
2、#define 只是简单的简单的体会，没有检查数据类型的作用
3、const，可以用于设置全局常量、类的常量成员、函数
4、在整个类中都用的恒定常量，只能通过枚举

void fun() & void fun()const构成重载

#include<iostream>
using namespace std;

class Test
{
public:
    Test(int d=0):data(d)
    {}
    //由上面知，this指针不能b改变，但所指的值可以修改
    //void fun(Test * const this)
    void fun()
    {
        data = 100;
    }
    //1.this指针不能修改 2.*this对象也不能修改，即对象的私有数据不能修改
    //void fun(const Test * const this)
    void fun()const
    {
        //data =100;
    }
    ~Test()
    {}
private:
    int data;

};
void main()
{
    //在构造对象之前，会产生this指针，将对象的地址传给了this指针。即this指针表示该当前的对象地址
    Test t(10);
    t.fun();
}