不可或缺 Windows Native (24) - C++: 运算符重载, 自定义类型转换

[源码下载]

不可或缺 Windows Native (24) - C++: 运算符重载, 自定义类型转换

作者：webabcd

介绍
不可或缺 Windows Native 之 C++

• 运算符重载
• 自定义类型转换

示例
CppOperator.h

#pragma once 

#include <string>

using namespace std;

namespace NativeDll
{
    class CppOperator
    {
    public:
        string Demo();
    };
}

CppOperator.cpp

/*
 * 运算符重载, 自定义类型转换
 */

#include "pch.h"
#include "CppOperator.h"
#include "cppHelper.h"
#include <iostream>

using namespace NativeDll;

void cppoperator_demo1();
void cppoperator_demo2();
void cppoperator_demo3();
void cppoperator_demo4();
void cppoperator_demo5();
void cppoperator_demo6();
void cppoperator_demo7();
void cppoperator_demo8();

string CppOperator::Demo()
{
    // 通过成员函数重载“+”运算符
    cppoperator_demo1();

    // 通过友元函数重载“*”运算符
    cppoperator_demo2();

    // 通过友元函数重载“==”运算符
    cppoperator_demo3();

    // 通过成员函数重载“前置++”运算符
    cppoperator_demo4();

    // 通过成员函数重载“后置++”运算符
    cppoperator_demo5();

    // 通过友元函数重载 ostream 的 <<
    cppoperator_demo6();

    // 类型转换函数（type conversion function），可以隐式转换或显式转换
    cppoperator_demo7();

    // 通过构造函数实现隐式转换
    cppoperator_demo8();

    // 运算符重载时，如果第一个操作数不是本类对象，则只能用 friend 的方式重载（此时不能用成员函数的方式重载）
    // 习惯来说：通过成员函数重载单目运算符；通过友元函数重载双目运算符
    // 不可以自定义新的运算符，只能重载已有运算符，其中不可重载的运算符有：“.”, “.*”, “sizeof()”, “::”, “?:”

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

class CppOperatorComplex
{
private:
    string Name;
public:
    CppOperatorComplex() : Name("")
    {

    }
    CppOperatorComplex(string name) : Name(name)
    {

    }
    string ToString()
    {
        return Name;
    }

    // 通过成员函数重载“+”运算符（左边是本类对象，右边是指定的 CppOperatorComplex 对象）
    CppOperatorComplex operator+(CppOperatorComplex &coc);

    // 通过友元函数重载“*”运算符（左边是指定的 CppOperatorComplex 对象，右边是指定的 CppOperatorComplex 对象）
    friend CppOperatorComplex operator*(CppOperatorComplex &coc1, CppOperatorComplex &coc2);
    // 通过友元函数重载“==”运算符（左边是指定的 string 对象，右边是指定的 CppOperatorComplex 对象）
    friend bool operator==(string &name, CppOperatorComplex &coc);

    // 通过成员函数重载“前置++”运算符
    CppOperatorComplex operator++();
    // 通过成员函数重载“后置++”运算符（这里需要加一个 int 类型的参数，这是 c++ 的约定，用以区分“前置++”）
    CppOperatorComplex operator++(int);

    // 通过友元函数重载 ostream 的 <<
    friend ostream& operator<<(ostream &, CppOperatorComplex &);

    // 类型转换函数，用以支持将 CppOperatorComplex 转换（隐式或显式）为 int
    operator int();
};

CppOperatorComplex CppOperatorComplex::operator+(CppOperatorComplex &coc)
{
    CppOperatorComplex result;
    result.Name = this->Name + "+" + coc.Name;
    return result;
}

CppOperatorComplex operator*(CppOperatorComplex &coc1, CppOperatorComplex &coc2)
{
    CppOperatorComplex result;
    result.Name = coc1.Name + "*" + coc2.Name;
    return result;
}

bool operator==(string &name, CppOperatorComplex &coc)
{
    CppOperatorComplex result;
    return name == coc.Name;
}

CppOperatorComplex CppOperatorComplex::operator++() // 前置++
{
    this->Name = "++" + this->Name;
    return *this;// 返回自加后的当前对象
}
CppOperatorComplex CppOperatorComplex::operator++(int) // // 后置++
{
    CppOperatorComplex temp(*this);
    this->Name += "++";
    return temp;  // 返回的是自加前的对象
}

ostream& operator<<(ostream &output, CppOperatorComplex &coc)
{
    output << "name: " << coc.Name;
    return output;
}

CppOperatorComplex::operator int() //定义重载运算符的函数
{
    if (this->Name == "webabcd")
        return ;
    return ;
}

// 通过成员函数重载“+”运算符
void cppoperator_demo1()
{
    CppOperatorComplex coc1("webabcd");
    CppOperatorComplex coc2("wanglei");

    CppOperatorComplex coc = coc1 + coc2;
    string result = coc.ToString(); // webabcd+wanglei
}

// 通过友元函数重载“*”运算符
void cppoperator_demo2()
{
    CppOperatorComplex coc1("webabcd");
    CppOperatorComplex coc2("wanglei");

    CppOperatorComplex coc = coc1 * coc2;
    string result = coc.ToString(); // webabcd*wanglei
}

// 通过友元函数重载“==”运算符
void cppoperator_demo3()
{
    string name = "wanglei";
    CppOperatorComplex coc2("wanglei");

    bool result = (name == coc2); // true
}

// 通过成员函数重载“前置++”运算符
void cppoperator_demo4()
{
    CppOperatorComplex coc("wanglei");

    string s1 = (++coc).ToString(); // ++wanglei
    string s2 = coc.ToString(); // ++wanglei
}

// 通过成员函数重载“后置++”运算符
void cppoperator_demo5()
{
    CppOperatorComplex coc("wanglei");

    string s1 = (coc++).ToString(); // wanglei
    string s2 = coc.ToString(); // wanglei++
}

// 通过友元函数重载 ostream 的 <<
void cppoperator_demo6()
{
    CppOperatorComplex coc("wanglei");

    cout << coc << endl; // name: wanglei
}

// 类型转换函数的演示，隐式转换和显式转换
void cppoperator_demo7()
{
    CppOperatorComplex coc1("webabcd");
    CppOperatorComplex coc2("wanglei");

    // 由于结果是 int 类型，所以 coc1 和 coc2 会被隐式地转换为 int（通过“operator int()”来实现）
    int result = coc1 - coc2; // 90

    // 显式转换（通过“operator int()”来实现）
    result = int(coc1) - int(coc2); //
}

class CppOperatorA
{
private:
    string Name;
    int Age;
public:
    CppOperatorA(string name) : Name(name), Age()
    {

    }
    CppOperatorA(int age) : Age(age), Name("")
    {

    }
    string ToString()
    {
        return Name + int2string(Age);
    }
};

class CppOperatorB
{
private:
    string Name;
    int Age;
public:
    explicit CppOperatorB(string name) : Name(name), Age()
    {

    }
    explicit CppOperatorB(int age) : Age(age), Name("")
    {

    }
    string ToString()
    {
        return Name + int2string(Age);
    }
};

// 演示如何通过构造函数实现隐式转换
void cppoperator_demo8()
{
    CppOperatorA a1 = "webabcd"; // 编译器会调用 CppOperatorA(string name); 构造函数
    CppOperatorA a2 = ; // 编译器会调用 CppOperatorA(int age); 构造函数

    string result1 = a1.ToString(); // webabcd0
    string result2 = a2.ToString(); // 100

    // CppOperatorB b1 = "webabcd"; // 由于构造函数 CppOperatorB(string name); 被修饰为 explicit，所以不能隐式调用此构造函数
    // CppOperatorB b2 = 100; // 由于构造函数 CppOperatorB(int age); 被修饰为 explicit，所以不能隐式调用此构造函数
}

OK
[源码下载]