C++中级-(静态成员和对象丶this指针丶常函数和对象、成员函数和对象)

类对象作为类成员

#include <iostream>
#include <string>
using namespace std;

//c++类中的成员可以是另一个类的对象，称为对象成员。
class A {
public:
    A() { cout << "A side \n"; };
    ~A() { cout << "Release A \n"; };

};

class B {

public:
    A a;//使用A作为对象成员
    B() { cout << "B side \n"; };
    ~B() { cout << "Release B \n"; };
};
//


int main() {
    B b;
    return 0;
}

静态成员变量

#include <iostream>
#include <string>
using namespace std;
//C++中使用静态成员变量来实现多个对象共享数据的目标，是一种特殊的成员变量。


class Person {
public:
    Person(string name, int age, int score) {};
    static int cont;//独立占一份内存
private:
    string name;
    int age;
    int score;
};
//成员变量必须在类声明的外部初始化,static 成员变量的内存既不是在声明类时分配，
//也不是在创建对象时分配，而是在（类外）初始化时分配.没有在类外初始化的 static 成员变量不能使用
int Person::cont = 0;



void dofun() {
    //通过类访问。
    Person::cont = 10;

    //通过对象访问。
    Person p("sd", 33, 60);
    cout << p.cont << endl;


    return;
}

int main() {
    dofun();

    return 0;
}

静态成员函数

#if 0
#include <iostream>
#include <string>
using namespace std;

/*编译器在编译一个普通成员函数时，会隐式地增加一个形参 this，
并把当前对象的地址赋值给 this，所以普通成员函数只能在创建对象后通过对象来调用，因为它需要当前对象的地址。
而静态成员函数可以通过类来直接调用，编译器不会为它增加形参 this，它不需要当前对象的地址，所以不管有没有创建对象，都可以调用静态成员函数。
*/

/*普通成员函数有 this 指针，可以访问类中的任意成员；
而静态成员函数没有 this 指针，
只能访问静态成员（包括静态成员变量和静态成员函数）*/

/*
所有对象共享同一个函数
只能访问静态成员变量
*/
class Person {
public:

    static void getcount() {
        age = 22;//静态函数内部能访问
        //score = 60;//非静态变量不能被访问，因为静态独占内存。
        cout << "Static func" << endl;
    }

    static int age;//静态变量
    int score;//非静态变量

};


int Person::age = 0;


void dofun() {

    //1.类访问
    Person::getcount();


    //2.对象访问
    Person p;
    p.getcount();

    return;
}

int main() {
    dofun();

    return 0;
}
#endif // 0

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

#if 0
#include <iostream>
using namespace std;

/*
Person p
*/


/*1.
cout << "空类对象占用内存:" << sizeof(p) << endl;
占1字节，C++为区分空间对象位置所以分配一份空间
*/
class Person {

};

/*2.
cout << "空类对象占用内存:" << sizeof(p) << endl;
4字节。int age属于类对象中的数据
*/
class Person2 {
    int age;

};

/*3.
cout << "空类对象占用内存:" << sizeof(p) << endl;
4字节。函数成员不属于类对象中的数据。
*/
class Person3 {
    int age;
    void func() {};

};

void Enter() {
    Person p;
}

int main() {
    Enter();
    return 0;
}

#endif // 0

常函数和常指针

#include <iostream>
using namespace std;



/*如果一个成员函数中没有调用非常量成员函数，
也没有修改成员变量的值，那么将其写成常量成员函数
*/

class Person {


public:
    void func() const//1.常函数
    {
        //age = 10;//常函数内部不能访问this->age。
        score = 60;//常变量，只有常函数可以访问
        cout << score << endl;

    }

    int age;
    mutable int score; //常变量，只有常函数可以访问
};




int main() { 
    const Person p1;//常对象只能调用常函数
    p1.func();

    Person p;
    p.func();

    return 0; 
}

This指针

#if 0
#include <iostream>
using namespace std;

/*this 是一个指针，它指向当前对象，通过它可以访问当前对象的所有成员。
要用->来访问成员变量或成员函数。
理解成python中的self。
*/

class Person {
public:
    int age;

    Person(int age)
    {
        this->age = age;//this指向当前类中的age
    };


};




int main() {

    Person p(18);
    cout << p.age << endl;

    return 0;
}
#endif // 0