不可或缺 Windows Native (24)，native24

不可或缺 Windows Native (24)，native24

[源碼下載]

作者：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 100;
    return 10;
}



// 通過成員函數重載“+”運算符
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); // 90
}



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

    }
    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(0)
    {

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

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

// 演示如何通過構造函數實現隱式轉換
void cppoperator_demo8()
{
    CppOperatorA a1 = "webabcd"; // 編譯器會調用 CppOperatorA(string name); 構造函數
    CppOperatorA a2 = 100; // 編譯器會調用 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
[源碼下載]