Cpp-04

this 指针

/*
    this 指针：
        1.this 指针是系统自动生成的，且隐藏的
        2.this 指针不是对象的一部分，作用域在类内部
        3.类的普通函数访问类的普通成员时，this 指针总是指向调用者对象 
*/

#include <iostream>
using namespace std;

class MyClass
{
    int num;

public:
    void setNum(int num)
    {
        this->num = num;
    }
    int getNum()
    {
        (*this).getNum();    // this 指针的灵活运用
        return num;
    }
};

int main()
{
    MyClass obj;
    obj.setNum(8);
    cout << obj.getNum() << endl;

    return 0;
}

static 成员

/*
    static（静态）关键字：
        1.静态成员分为“静态数据成员”和“静态函数成员”
        2.不管这个类实例化了多少个对象，这些对象都能够共享(类里面的)“静态区域”里面存的“静态数据”，即这些数据是共有财产
*/

#include <iostream>
using namespace std;

class MyClass
{
public:
    static int num;        // (静态数据成员)给初值的话，要在外面进行，如下
    MyClass();
    static void func();    // 静态函数成员
};

int MyClass::num = 0;    // 如上

void MyClass::func()
{
    cout << "func" << endl;
}

MyClass::MyClass()
{
    num++;        // 每创建一个对象，就记录一下
}

int main()
{
    MyClass obj_1;
    cout << obj_1.num << endl;

    MyClass obj_2;
    cout << obj_2.num << endl;

    MyClass obj_3;
    cout << obj_3.num << endl;

    MyClass::num;    // 因为数据 num 是在静态区域，所以还能通过类来访问

    // 静态函数成员的访问
    obj_3.func();
    MyClass::func();    // 因为函数在静态区域，可以通过类来访问
    (&obj_3)->func();    // 通过指针进行访问

    return 0;
}

单例模式

/*
    (入门级别)单例模式：创建一个只能实例化一个对象的类
*/

#include <iostream>
using namespace std;

class Human
{
public:
    static Human* func();

private:
    Human();    // 构造
    Human(const Human& obj);    // 拷贝构造
    static Human* p;        // 需要在外面给初始值，如下
};

Human* Human::p = NULL;        // 给初始值操作

Human* Human::func()
{
    if (p == NULL)
    {
        p = new Human;    // 给更新值操作(只更新一次)
    }
    return p;
}

Human::Human()    // 声明了构造，就一定要写，即使函数里面什么都不做
{}
Human::Human(const Human& obj)
{}


int main()
{
    
    Human* p1 = Human::func();
    cout << hex << p1 << endl;    // hex 以16进制输出

    Human* p2 = Human::func();
    cout << hex << p2 << endl;

    Human* p3 = Human::func();
    cout << hex << p3 << endl;
    
    return 0;
}

const 成员

/*
    const 关键字：
        1.常量成员分为"常量数据成员"和"常量函数成员"
        2.使用了 const，就不能修改内部数据
        3.补充知识：常对象
*/

#include <iostream>
using namespace std;

class Human
{
public:
    const int num;        // 常量数据成员，初始化必须用"成员初始化列表"

    Human();        // 无参构造
    Human(int a);    // 含参构造

    void func()const;    // 常量函数成员

    static int m;    // 静态(数据)成员
};
int Human::m = 0;

Human::Human() :num(5)    // 成员初始化列表
{}
Human::Human(int a) : num(a)    // 成员初始化列表
{}

void Human::func()const
{
    cout << num << endl;    // 在常量函数成员中，普通的数据成员，如 num 等，只能读，不能改
    m = m + 5;                // 在常量函数成员中，静态数据成员，如 m 等，可以修改
    this->m = 99;
}



int main()
{
    // 下面两种都是“常对象”-----整个对象里面的数据都不能改，静态数据除外
    const Human obj;
    Human const obj;

    return 0;
}

友元关系

/*
    友元关系:
        1.类的特性之一是封装，友元是打破封装的手段 ( 不要滥用！！)
        2.友元分为"友元函数"和"友元类"
        3.友元类，可以创建友元对象
*/

// 友元函数


#include <iostream>
using namespace std;

class A
{
private:
    int num;
    friend void func(A obj);    // 友元关键字 friend
public:
    A(){ num = 0; }        // num 初始化
};

void func(A obj)    // 普通函数
{
    obj.num = 6;    // 本来是不能访问类中私有的 num 的，但是因为上面加了 friend
}


int main()
{
    A obj_1; 
    func(obj_1);

    return 0;
}

// 友元类


#include <iostream>
using namespace std;

class A
{
private:
    int num;
    friend class B;        // 把 B 当作朋友（单方面）
};

class B
{
public:
    void func(A obj)
    {
        obj.num;    // 本来是不能访问 A 中的私有成员 num，但是因为 A 中加上了 friend，从此 B 中都能使用
    }
};

int main()
{
    return 0;
}