C++必备 Windows Native (18) – C++: this 指针, 对象往往组, 对象以及指针, const 对象, const 指针和指向 const 对象的指针, const 对象的援

[源码下载]

必要 Windows Native (18) – C++: this 指针, 对象往往组, 对象和指针,
const 对象,  const 指针和对 const 对象的指针, const 对象的援

作者:webabcd

介绍
必要 Windows Native 之 C++

  • this 指针
  • 对象数组
  • 对象及指针
  • const 对象
  • const 指针和针对 const 对象的指针
  • const 对象的援

示例
1、CppEmployee 类
CppEmployee.h

#pragma once 

#include <string>

using namespace std;

namespace NativeDll
{
    class CppEmployee
    {

        int Number; // 默认为 private

    private: // 以下都是 private 的
        string Name;
        bool IsMale;

    protected: // 以下都是 protected 的
        string ToString();

    public: // 以下都是 public 的
        float Salary;
        int Age;
        string Show();

        // 构造函数(constructor),不定义的话,编译时会自动生成一个默认的不做任何事情的无参数构造函数(如果指定为 private 的话就可以禁止直接实例化,一般做单例模式的话会这么做)
        // 另外:如果声明了带参数的构造函数,则不会自动生成默认的无参数构造函数
        CppEmployee();
        CppEmployee(int number, string name = "webabcd"); // 可以为构造函数中的参数指定默认值(参考:CppFunction1.cpp)
        CppEmployee(int number, string name, bool isMale);

        // 析构函数(destructor),对象被销毁时会调用,例如释放动态分配的内存等。不需要时也可以不定义,编译时会自动生成一个默认的不做任何事情的析构函数,析构函数的函数名与类名相同,前面有“~”
        ~CppEmployee();

    private:
        // 注:在体内定义的成员函数,系统会自动将其作为 inline 函数处理(关于 inline 函数,参见:CppFunction2.cpp)
        void Temp()
        {
            int a = 100;
        }

        /*
        下面这个与上面那个一样
        inline void Temp()
        {
            int a = 100;
        }
        */

    };
}

CppEmployee.cpp

/*
 * CppEmployee 类
 */

#include "pch.h" 
#include "CppEmployee.h" 
#include "cppHelper.h"

using namespace NativeDll;

// “::”是作用域限定符(field qualifier)
string CppEmployee::Show()
{
    return int2string(Number) + " " + Name;
}

string CppEmployee::ToString()
{
    return int2string(Number) + " " + Name;
}

// 无参数的构造函数
CppEmployee::CppEmployee()
{
    Number = 888;
    Name = "webabcd";
}

// 有参数的构造函数,可以在声明中为参数指定默认值
CppEmployee::CppEmployee(int number, string name)
{
    Number = number;
    Name = name;
}

// 可以通过下面这种简单的方式,将构造函数中的参数值赋值给对象的变量
CppEmployee::CppEmployee(int number, string name, bool isMale) :Number(number), Name(name), IsMale(isMale)
{

}

CppEmployee::~CppEmployee()
{

}

2、演示 this 指针, 对象往往组, 对象以及指针, const 对象,  const 指针和针对性
const 对象的指针, const 对象的援
CppClass2.h

#pragma once 

#include <string>

using namespace std;

namespace NativeDll
{
    class CppClass2
    {
    private:
        string Name;

    public:
        string Demo();
    };
}

CppClass2.cpp

/*
 * this 指针, 对象数组, 对象和指针, const 对象,  const 指针和指向 const 对象的指针, const 对象的引用
 */

#include "pch.h" 
#include "CppClass2.h" 
#include "CppEmployee.h" 

using namespace NativeDll;

void cppclass2_demo1();
void cppclass2_demo2();
void cppclass2_demo3();
void cppclass2_demo4();
void cppclass2_demo5();

string CppClass2::Demo()
{
    // 什么是 this 指针:
    // 在每一个成员函数中都包含一个特殊的指针,即 this 指针。它是指向本类对象的指针,它的值是当前被调用的成员函数所在的对象的起始地址
    this->Name = "abc";
    string name = (*this).Name;


    // 对象数组
    cppclass2_demo1();

    // 对象和指针
    cppclass2_demo2();

    // const 对象
    cppclass2_demo3();

    // const 指针和指向 const 对象的指针
    cppclass2_demo4();

    // const 对象的引用
    cppclass2_demo5();


    return "看代码及注释吧";
}



// 对象数组
void cppclass2_demo1()
{
    // 对象数组
    CppEmployee employees[3] =
    {
        CppEmployee(1, "name1"),
        CppEmployee(2, "name2"),
        CppEmployee(3, "name3")
    };

    // 数组名 employees 就是该数组的首地址
    employees->Show(); // 1 name1
}



// 对象和指针
void cppclass2_demo2()
{
    CppEmployee employee(1, "webabcd"); 


    // 指向对象的指针
    CppEmployee *p1 = &employee;
    p1->Salary = 1000;


    // 指向对象中的指定属性的指针
    float *p2 = &employee.Salary; // . 的优先级高


    // 函数指针(指向函数的指针)
    string (CppEmployee::*p3)(); // 定义一个函数指针。此函数为 CppEmployee 类中的一个 public 函数,其无参数,返回值为 string 类型
    p3 = &CppEmployee::Show; // 使 p3 指向 CppEmployee 类中的 public 函数 Show
    string result = (employee.*p3)(); // 调用对象 employee 中 p3 所指的函数

    string(CppEmployee::*p4)() = &CppEmployee::Show;
    result = (employee.*p4)(); // 1 webabcd
}



namespace NativeDll
{
    class CppEmployeeConst
    {

    public: 
        float Salary;
        int Age;
        mutable int Num; // mutable 属性,即使对象是 const 对象的话,也可以设置其 mutable 属性
        const string Name; // const 数据成员
        const boolean IsMale; // const 数据成员

        string Show() const // const 成员函数(注意 const 写在后面)
        {
            // const 函数不能调用非 const 函数
            // return this->ToString();

            return "abc";
        }

        string ToString()
        {
            return "abc";
        }

        // 必须提供一个构造函数,用以初始化所有 const 数据成员
        CppEmployeeConst(string name) :Name(name), IsMale(true)
        { 
            this->Age = 35;
        }
    };
}

// const 对象
void cppclass2_demo3()
{
    // 实例化一个非 const 对象
    CppEmployeeConst employee("webabcd");
    // 不能修改对象中的 const 属性
    // employee.IsMale = true;



    // 实例化一个 const 对象
    // CppEmployeeConst const employeeConst;
    const CppEmployeeConst employeeConst("webabcd");

    // 可以获取 const 对象中的 const 属性和非 const 属性
    string name = employee.Name;
    int age = employee.Age;

    // 不能设置 const 对象中的 const 属性和非 const 属性
    // employee.Salary = 100;
    // employee.Name = "wanglei";

    // 可以设置 const 对象中的 mutable 属性
    employee.Num = 88;

    // 可以调用 const 对象中的 const 函数,不能调用非 const 函数
    employee.Show();
    // employee.ToString();
}



// const 指针和指向 const 对象的指针
void cppclass2_demo4()
{
    CppEmployee employee(1, "webabcd");
    CppEmployee employee2(1, "webabcd");


    // const 指针:指针始终指向同一个对象(指针是 const 的)
    CppEmployee *const p1 = &employee;
    // p1 = &employee2; // 编译错误,因为指针是 const 的,不能对其赋值


    // 指向 const 对象的指针(所指的对象是 const 的)
    const CppEmployee *p2 = &employee;
    // p2->Salary = 100; // 编译错误,因为所指的对象是 const 的,不能对其属性赋值


    // 当使用指针的方式传参时,如果不希望在函数中修改其所指的对象,则可以这么做
    void cppclass2_function1(const CppEmployee *p);
    cppclass2_function1(&employee);
}

void cppclass2_function1(const CppEmployee *p)
{
    // 不能在此函数中修改 p 所指对象
    // p->Salary = 100;
}



// const 对象的引用
void cppclass2_demo5()
{
    CppEmployee employee(1, "webabcd");
    CppEmployee employee2(1, "webabcd");


    // const 对象的引用(被引用的对象是 const 的)
    const CppEmployee &r = employee;
    // r.Salary = 100; // 编译错误,因为被引用的对象是 const 的,不能对其属性赋值


    // 当使用引用的方式传参时,如果不希望在函数中修改其引用的对象,则可以这么做
    void cppclass2_function2(const CppEmployee &r);
    cppclass2_function2(r);
    cppclass2_function2(employee);
}

void cppclass2_function2(const CppEmployee &r)
{
    // 不能在此函数中修改 r 所引用的对象
    // r.Salary = 100;
}

OK
[源码下载]