C++知识点示例2

#pragma once
class CMyClsB {
public:
    void Fun();
};

---

#include "stdafx.h"
#include "CMyClsB.h"


void CMyClsB::Fun() {

}

---

#include "stdafx.h"

class MyClsA {
public:
    char m_c;
    int m_nA;
    char m_d;
    // 类内定义
    void Fun() {
        // this：调用当前函数的对象的地址
        printf("%d", this->m_d);
    }
    // 声明类里，实现类外
    void Fun2();
protected:
    int m_nE;
private:
};

void MyClsA::Fun2() {
    printf("%d",m_nE);
}

int g_nNumA;

//void Fun(MyClsA obj) {
//  printf("%d", obj.m_nE);
//}

MyClsA objA;

int main()
{
    objA.m_nA = 100;
    objA.Fun();
    MyClsA obj;
    obj.m_nA = 200;
    obj.Fun();

    MyClsA arrObj[5];
    obj.Fun();
    obj.Fun2();
    int g_nNumA;
    int a = ::g_nNumA;
    MyClsA *p = new MyClsA;
    delete p;
    return 0;
}

======================================

// 01.构造函数.cpp: 定义控制台应用程序的入口点。
//

#include "stdafx.h"

class CMyClsA {
public:
    CMyClsA() {
        m_cA = 'a';
        m_nNumA = 10;
        m_p = new char[10]{};
    }
    ~CMyClsA() {
        if (m_p) {
            delete[] m_p;
            m_p = nullptr;
        }
    }
    int m_nNumA;
    char m_cA;
    char *m_p;
};

CMyClsA g_objA;

int FunA(int a) {
    return a;
}



int main() {
    CMyClsA obj;
    // 调用一次
    CMyClsA *p = new CMyClsA;
    // 数组调用构造函数的次数和数组元素个数一致
    CMyClsA arrObj[10];
    return 0;
}

int g_nNumC = FunA(20);

==============================

// 02.构造析构的调用顺序.cpp: 定义控制台应用程序的入口点。
//

#include "stdafx.h"

class CClsA {
public:
    CClsA() {
        printf("A\n");
    }
    ~CClsA() {
        printf("~A\n");
    }
};
class CClsB {
public:
    CClsB() {
        printf("B\n");
    }
    ~CClsB() {
        printf("~B\n");
    }
};
class CClsC {
public:
    CClsC() {
        printf("C\n");
    }
    ~CClsC() {
        printf("~C\n");
        //m_objB.~CClsB();
        //m_objA.~CClsA();
    }
    CClsB m_objB;
    CClsA m_objA;
    char * m_p;
};

int main()
{
    CClsC obj;
    return 0;
}

==============================

// 03.带参构造和初始化列表.cpp: 定义控制台应用程序的入口点。
//

#include "stdafx.h"

class CTest {
public:
    CTest(int a) {
        m_a = a;
    }
    CTest() {
        m_a = 10;
    }
    int m_a;
};


class CMyCls {
public:
    CMyCls(int a)
    :m_nNumB(a),m_obj(a)
    {
        //m_obj(10);// m_obj(10)->函数名为m_obj参数为10的函数调用
        m_nNumA = a;
        m_cA = 'a';
    }
    CTest m_obj;
    int m_nNumA;
    char m_cA;
    const int m_nNumB = 10;
};

int main()
{
    const int a = 10;
    //a = 100;
    int b = 10;
    b = 100;
    int &c = b;
    c = 20;
    return 0;
}

=======================================

// 04.拷贝构造.cpp: 定义控制台应用程序的入口点。
//

#include "stdafx.h"

class CMyClsA {
public:
    CMyClsA(int a) {
        m_nNumA = a;
        m_pSz = new char[10]{"12345"};
    }
    ~CMyClsA() {
        if (m_pSz)
        {
            delete[] m_pSz;
            m_pSz = nullptr;
        }
    }
    // 默认拷贝构造函数->浅拷贝
    //CMyClsA(CMyClsA &objC) {
    //  memcpy_s(this, sizeof(CMyClsA), &objC, sizeof(CMyClsA));
    //}
    
    // 深拷贝
    CMyClsA(const CMyClsA& objC) {
        // 先把内存拷贝一份
        memcpy_s(this, sizeof(CMyClsA), &objC, sizeof(CMyClsA));
        // 再把相关资源拷贝一份
        m_pSz = new char[10];
        memcpy_s(m_pSz, 10, objC.m_pSz, 10);
        printf("CMyClsA\n");
    }
    int m_nNumA;
    char *m_pSz;
};

CMyClsA& Fun(CMyClsA& obj) {
    printf("void");
    return obj;
}

int main()
{
    int a = 10;
    int b = a;
    CMyClsA obj(10);
    // 构造函数调用
    // CMyClsA objC = obj;
    //CMyClsA objA = obj;
    CMyClsA &objC = Fun(obj);
    return 0;
}

================================

// 05.转换构造函数.cpp: 定义控制台应用程序的入口点。
//

#include "stdafx.h"

class CMyClsA {
public:
    CMyClsA(const int a) {
        m_nNumA = a;
    }
    CMyClsA(char c) {
        m_C = c;
    }
    void Fun()const {
    }
    int m_nNumA;
    char m_C;
};

int main()
{
    CMyClsA objA = 10;//CMyClsA objA(10);
    int a = 10;
    int b(10);
    //b(20); b = 20;
    //CMyClsA objB = 'a';
    &objA;
    //objB = (CMyClsA)20;
    return 0;
}

====================================

// 06.静态成员.cpp: 定义控制台应用程序的入口点。
//

#include "stdafx.h"

int g_nCount = 0;

class 学生 {
public:
    学生() {
        m_nCount++;
    }
    ~学生() {
        m_nCount--;
    }
    学生(const 学生& obj) {
        m_nCount++;
    }
    static int GetCount() {
        printf("%d\n", m_nCount);
        printf("%d\n", m_nNumA); //error,必须通过类对象访问
        return m_nCount;
    }
    int m_nNumA;
private:
    static int m_nCount;
};

int 学生::m_nCount = 0;

void GetCount() {
    // 只能访问类的public成员
    printf("%d\n", 学生::m_nCount);
}
int main()
{
    学生 obj1, obj2;
    学生::GetCount();
    obj2.GetCount();
    printf("sizeof(学生)= %d\n", sizeof(学生));
    return 0;
}

==============================