2.C++类和对象

类和对象赋初值的方法

当其它类作为对象为本类成员，构造是先去构造类对象，在构造自身，析构的顺序
析构的时候先析构自身，在析构作为对象为本类的成员。

class Person
{
 public:
//传统的初始化方法
Person(int a, int b, int c)
{
  m_A = a;
  m_B = b;
  m_C = c
}
//列表初始化
    Person(int a, int b, int c): m_A(a), m_B(b), m_C(c)
{

}
int m_A;
int m_B;
int m_C;
 }

void test01()
{
    Person p(30, 20, 10)
    cout << "m_A = " << p.m_A << endl;
}

对象类作为类成员

#include<iostream>
#include<string>
using namespace std;
class Phone
{
public:
    Phone(string pName)
    {
        cout << "这是Phone构造函数" << endl;
        m_PName = pName;
    }
    ~Phone()
    {
        cout << "这是Phone析构函数" << endl;
    }
    string m_PName;
};


class Person
{
public:
    Person(string name, string pName): m_name(name), m_Phone(pName)
    {
        cout << "这是人的构造函数" << endl;
        //m_name = name;
        //m_Phone.m_PName = pName;
    }
    ~Person()
    {
        cout << "这是Person的析构函数" << endl;
    }
    //姓名
    string m_name;
    //手机
    Phone m_Phone;
};
//当其它类作为对象为本类成员，构造是先去构造类对象， 在构造自身，析构的顺序


void test01()
{
    Person p("张三", "苹果MAX");
    cout << p.m_name << "拿着" << p.m_Phone.m_PName << endl;
}

int main()
{
    test01();
    system("pause");
    return 0;

}

输出结果

静态成员函数和静态成员变量

静态成员函数：所有对象共享同一个函数
静态成员函数只能访问静态成员变量
静态变量的两种访问方式

#include<iostream>
#include<string>
using namespace std;
class Person
{
public:
    //静态成员函数
    static void func()
    {
        cout << "static void func 调用" << endl;
    }

};
void test01()
{
    //1.通过对象访问
    Person p;
    p.func();

    //2.通过类名访问
    Person::func();
}

类静态变量和静态函数

静态成员函数可以访问静态成员变量
静态函数不能访问非静态成员变量，无法区分到底是哪个对象的
类外访问不到

//1.通过对象访问
//2.通过类名访问

#include<iostream>
#include<string>
using namespace std;
class Person
{
public:
    //静态成员函数
    static void func()
    {
        m_A = 100;//静态成员函数可以访问 静态成员变量
        //m_B = 200;//静态函数不能访问非静态成员变量，无法区分到底是哪个对象的m_B
        cout << "static void func 调用" << endl;
    }
    static int m_A;//静态成员变量
    int m_B;
private:
    static void func2()
    {
        cout << "sattic void func2调用" << endl;
    }
};
void test01()
{
    //1.通过对象访问
    Person p;
    p.func();
    //2.通过类名访问
    Person::func();
    //Person::func2();//类外访问不到
}
int main()
{
    test01();
    system("pause");
    return 0;
}

类成员变量和成员函数的关系

//空对象占用内存空间为:1
//C++编译器会给每个空对象也分配一个字节空间,是为了区分空对象占内存的位置
//每个空对象也应该有一个独一无二的内存地址

//
class Person
{
};
void test01()
{
    Person p;
    //空对象占用内存空间为:1
    //C++编译器会给每个空对象也分配一个字节空间,是为了区分空对象占内存的位置
    cout << "sizeof p : " << sizeof(p) << endl;
}

image.png

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

#include<iostream>
#include<string>
using namespace std;
//成员函数和成员变量分开存储
class Person
{
public:
    static int m_B; // 静态成员变量 不属于类对象上
    void func() {}//非静态成员函数
    int m_A;
    int m_C;
};
void test01()
{
    Person p;
    //空对象占用内存空间为:1
    //C++编译器会给每个空对象也分配一个字节空间,是为了区分空对象占内存的位置
    cout << "sizeof p : " << sizeof(p) << endl;
}
void test02()
{
    Person p;
    cout << "sizeof p : " << sizeof(p) << endl;
}
int main()
{
    test02();
    system("pause");
    return 0;
}

最后编辑于：2020.09.10 08:09:33