operator 運算子的各式標準寫法與原因

tags: C++ Concept2

operator存在著許多應該遵守的公約，這裡會列出常見的operator如何撰寫標準公約，並說明為何要如此撰寫與舉例

宣告

/* 那些只有一行的函式可以直接上inline */

// +運算子
Arr & operator+=(Arr const &rhs);
friend Arr const operator+(Arr const &lhs, Arr const &rhs);
    return Arr(lhs) += rhs; // op+的定義

// 下標運算子
int & operator[](size_t idx){
    return const_cast<int&>(static_cast<const Arr&>(*this)[idx]);
}
const int & operator[](size_t idx) const;

// <<運算符號
friend ostream & operator<< (ostream& s, const Rati & r);

// 複製建構子
List(List const & rhs);
// 複製函式
List & operator=(List const & rhs);

// 移動建構子
List(List && rhs){
    (*this) = std::move(rhs);
}
// 移動函式
List & operator=(List && rhs);

// 取址
T* operator&();
// 取值(轉型)
operator T&();

// ++T
Arr & operator++();
// T++
Arr operator++(int);

公約

盡可能記住他，在大多數的可以幫你避開很多坑

參數

看一下以下的例子，這樣的寫法可以同時接收const與non-const

void fun(int const & num){
    cout << "num=" << num << endl;
}

int i=0;
fun(i);

1. 避免寫兩個 fun() 函式
2. 不小心修改到時編譯器會提醒你

參數能夠加上 const 就加上 const

返回的物件

假設一個沒有被加上const物件被返回可能會發生這種事情

Arr operator+(Arr const &lhs, Arr const &rhs);

Arr a, b;
a+a=b;

或許你不會這寫，但不能保證沒有人會這樣寫，嘗試對一個即將被解構的物件修改，其結果只是浪費效能。

返回的物件能夠加上 const 就加上 const

返回 (*this) 的參考

我們應該效仿基本的型別操作，int這些基礎型別是可以連續被指定的

int a, b, c, d;
a=b=c=d=1;

我們只要傳出 (*this) 的參考就可以做到這樣的操作，可以把他們拆解成原本的樣態，可以更容易理解

Arr a, b, c;
a=b=c;

a.operator=(b.operator=(c));

適當的使用全域函式

當我們使用 op+() 的時候要注意一種情況

Arr a;
a+1;

這把它還原看起來沒問題

a.operator+(1);

可是反過來就出問題

1.operator+(a);

這可以使用全域函式處理

Arr const operator+(int lhs, Arr const &rhs);
Arr const operator+(Arr const &lhs, int rhs);

適當的引用重複的函式

可以觀察到某些函式其實是具有重複性的

• op+() 可以拆解為兩個已有的函式，複製後+=
• 下標負號的 const 與 non-const
• 移動建構子的內容與移動函式相等
• 複製建構子與複製函式部分相同(額外拆一個函式呼叫)

拆解

一個相加的函式可以拆解為

int a=1, b=2;

int temp=a;
temp+=b;

下標符號比較特別需要特別為了 const 與 non-const 寫兩個完全一樣的函式

int & operator[](size_t idx);
const int & operator[](size_t idx) const;

Arr a;
const Arr b;

a[0]=1;
b[0];

解決方法長這個樣子

int & operator[](size_t idx){
    return const_cast<int&>(static_cast<const Arr&>(*this)[idx]);
}

簡單來說從右邊看回來

1. 先加上const屬性
2. 然後讓它去呼叫const的op[]()函式
3. 再強制解除他的 const 屬性

順序不要反過來了把主代碼寫在 non-const (是可以正常運行的)

讓 const 去呼叫 non-const 的函式

這樣會導致函式運行的時候 const 屬性被解除可以被修改。
難保後面的人沒察覺到…(通常這個人是幾個月後的自己)

補上 friend 開放 private 的存取權限

某些函式寫在全域函式會比寫在成員函式還要來的好，可是一旦寫到全域函式去之後，相對的就會失去對private成員的存取權限

在類別的定義裡面補上該全域函式的 friend宣告，讓全域函式可以有應有的權限操作成員函式

待續

​

繼承的虛擬函式與純虛擬函式的實際作用

tags: C++ Concept2

一句話形容虛擬函式的意思

該函式可有可無

這在繼承的時候起了一個極大的用處，基層類別的函式可有可無的特性會讓編譯器自動選擇正確的函式，稍後會繼續說明。

需要遵守的原則

總是讓你的Base擁有虛擬解構子

否則一個向上轉型的指針會被錯誤的解構

一句話形容純虛擬函式

禁止使用者操作你的父類別

你不會希望使用者可以操作你的父類別的，它只是用來定義或抽出各個類別相同處。

繼承

以下均是討論在繼承的情況下會遇到的問題

繼承的參考代碼

class Base{
public:
    Base(){}
    ~Base(){
        cout << "Base dtor" << endl;
    }
    void fun(){
        cout << "Base" << endl;
    }
};

class Drived: public Base{
public:
    Drived(){}
    ~Drived(){
        cout << "Drived dtor" << endl;
    }
    void fun(){
        cout << "Drived" << endl;
    }
};

函式多載

如果一個子類別加載了與父類別相同名稱的函式，那麼那個函式將會被覆蓋，子類別宣告的物件依子類別函式為主。

Base ba;
Drived dr;
ba.fun();
dr.fun();

結果會個別呼叫父類別與子類別的 fun()函式，如果子類別沒有宣告該函式則會繼承父類別的函式。

向上轉型

使用父類別指針來宣告子類別非常常見；有些時候也有必要進行安全的向上轉型(子類別指針轉成父類別)，這種情況下，會出現一個問題

這個子類別會呼叫父類別的函式

試著在上述的代碼加入

Base* p = new Drived;
p->fun();

結果將呼叫父類別的 fun()函式

這可能不是我們要的結果，將fun()設置成虛擬函式，可以讓編譯器選擇正確的函式運行。

virtual void fun(){
    cout << "Base" << endl;
}

現在可以正確地呼叫子類別的 fun()函式 了。

不正確的解構

上述情況呼叫錯誤的函式這聽起來可能沒什麼事情，但是如果呼叫錯解構子可就有問題了。

Base* p = new Drived;
delete p;

這是一個未定義行為，讓一個子類別呼叫父類別的解構子，其結果可能導致記憶體遺失。必須為你的父類別的解構子加上 vitual，才能呼叫正確的解構子

不想讓使用者使用父類別

繼承最重要的目的之一就是抽出各個函式相同之處，集中寫到同一個類別內，再分別讓大家既成。

可問題就在於集中到的那個類別如果被使用者拿去使用宣告會發生什麼事情？可能不會發生什麼，不過你不會希望他被使用者拿去操作，因為這一點實用性都沒有。

抽象類別的定義

抽象類別指的是其成員函式至少具有一個純虛擬函式，純虛擬函式的寫法是另一個虛擬函式=0。

virtual void fun()=0;

抽象類別不能夠實際產生出一個物件，僅能夠被繼承。基於這一點可以完美的阻止使用者操作Base類別。

找不到適當的函式當作純虛擬函式?

還記得前面提到的總是讓你的Base擁有虛擬解構子嗎？我們可以從這裡下手，反正他都已經必須是了，並在代碼之後補上其定義，不讓使用者定義，可以完整的解決這個問題。

virtual ~Base()=0;

Base::~Base(){
    cout << "Base dtor" << endl;
}

現在使用者構不著你的Base類別了，並且你也不用為了純虛擬函式煩惱要怎麼生出一個新函式，對使用者而言也不需要自行補上純虛擬函式的定義。

範例代碼

/*****************************************************************
Name : 
Date : 2017/04/30
By   : CharlotteHonG
Final: 2017/04/30
*****************************************************************/
#include <iostream>
using namespace std;

class Base{
public:
    Base(){}
    virtual ~Base()=0;
    virtual void fun(){
        cout << "Base" << endl;
    }
};
Base::~Base(){
    cout << "Base dtor" << endl;
}

class Drived: public Base{
public:
    Drived(){}
    ~Drived(){
        cout << "Drived dtor" << endl;
    }
    void fun(){
        cout << "Drived" << endl;
    }
};
//================================================================
int main(int argc, char const *argv[]){
    Base* p = new Drived;
    delete p;
    return 0;
}
//================================================================

​

Operator 隱式轉換的重載，物件的轉出與轉入

tags: operator2

你可以把一個新的物件當作一個型態看待，就像int是一個整數型態裡面什麼都沒有就只有一個成員int，這樣的概念，我們可以自訂一個型態。

這個型態你可以決定用什麼方式初始化他

class Opcast {
public: //建構子
    Opcast(int i): i(i) {}
private:
    int num;
};

比如說妳決定創建一個屬於自己的整數型態，可以這樣建立，且你可以從主程式初始化。

int main(int argc, char const *argv[]){
    Opcast a(int(1));
    return 0;
}

你也可以選擇輸入他類型的變數，比如說 double，在輸入的時候轉換成int讓引數符合初始化參數。static_cast<int>(num) 你可以把它看成 (int)num ，但前者是更好的寫法。

int main(int argc, char const *argv[]){
    double num = 1.0;
    Opcast a(static_cast<int>(num));
    return 0;
}

這裡我提一個自己的類比概念轉入，簡而言之就知把另一個型態轉入這個型態。還有一個概念是轉出，比如說這裡的 (int)num 以int的型態轉出給main使用。

你可能已經注意的到括號的使用右邊轉入，左邊轉出。

int i=0;
cout << Opcast(i) << endl;

Opcast a;
cout << (int)a << endl;

前者是把 i 導入，後者則是把 a 以 int 型態導出，這個以int形式導出的 行別轉換函式 是一個operator，這可能比較難想像。

函式的樣貌長這個樣子

Opcast::operator int() const{
    return i;
}

看你想重載導出什麼樣貌就寫什麼型態，後面的const是為了讓它可以同時接收兩種型態的呼叫

Opcast a(0);
const Opcast b(0);

這個樣子看起來一切很很美好，但實際上轉出與轉入它潛藏著不容易被發現的危機

轉入的隱式轉換

如果你有一個副程式接收了妳的自訂類別，而且那個自訂類別參數只有一個

Opcast::Opcast(int i): num(i) {}

void fun(Opcast a){
    cout << "fun" << endl;
}

我們試著呼叫他

fun(1);

理應是找不到定義為整數的方程式

void fun(int);

而實際上，編譯器會想辦一切辦法奏和出恰當的轉換，那個呼叫會變成

fun( Opcast(1) );

產生的結果可能不是你想要的，你可以透過關鍵字 explicit 避免這種編譯器自作主張的轉換

explicit Opcast::Opcast(int i): num(i) {}

傳統的解決方案(C11之前沒有這個關鍵字)，可以使用替身類別來處理

class OpcastSize{
public:
    OpcastSize(int i): len(i){}
    operator int&(){return len;}
    int len;
};

Opcast::Opcast(OpcastSize i): num(i) {}

轉出的隱式轉換

如果你加載了型別轉換的函式要注意它有可能在你不需要的時候自作主張的呼叫

    Opcast a(1);
    cout << a << endl;

看起來因該會因為你沒有加載 << 運算子而導致呼叫失敗，實際上因為你加載了型別轉換函式，編譯器將會發現經過型別轉換後就可以正常印出了，而自作主張的幫你轉換。

這裡一樣可以使用關鍵字 explicit 來避免這種狀況

explicit operator double() const{...}

傳統的方案是乾脆不寫了，另外單獨使用一個普通函式來轉出，可以觀察 string 裡面的函式 c_str() 來進行型別的轉換。

這樣的寫法比較明確不會有其他可能的誤解，誤會成我是否可以將他轉成其他的任意型態，比如說 int、double。

其次也可以減少代碼的長度，C++的正確轉型方式為 static_cast<T>(t) 非常的長呢。

範例代碼

 /*****************************************************************
Name : Operator 隱式轉換的重載
Date : 2017/04/11
By   : CharlotteHonG
Final: 2017/04/11
*****************************************************************/
#include <iostream>
using namespace std;

class Opcast {
public:
    class OpcastSize{
    public:
        OpcastSize(int i): len(i){}
        operator int&(){return len;}
        int len;
    };
public: //建構子
    // ##轉入會被隱式轉換
    Opcast(int i): num(i) {}
    // 解決方法 1
    // explicit Opcast(int i): num(i) {}
    // 解決方法 2
    // Opcast(OpcastSize i): num(i) {}
public: // 轉型函式
    operator double() const{
        cout << "Cast to double. --> ";
        return num+1;
    }
    double to_dou(){
        cout << "Cast to double. --> ";
        return num+1;
    }
private:
    int num;
};

void fun(Opcast a){
    cout << "fun" << endl;
}
/*==============================================================*/
int main(int argc, char const *argv[]){
    Opcast a(1);
    // 轉入的隱式轉換
    cout << a << endl;
    // 轉出的隱式轉換
    fun(10);
    return 0;
}
/*==============================================================*/

​

Win10 中文輸入法消失不見了 無法輸入中文

先按一下CTRL+空白看看，按到會關閉輸入法打不出中文。

也不曉得怎麼觸發的，就忽然不見了，可以嘗試重這裡重啟輸入法，重啟輸入法之後要重開機，然後就正常了

位置

先按一下開始，然後直接貼上 工作排程 會自動搜索

進來之後左邊資料開始開依序是

工作排程器程式集 -> Microsoft-Windows -> TextServicesFramework ->

然後看右邊有個 MsCtfMonitor 對他點右鍵執行

然後重新開機吧~之後就一切正常了

地區及語言

也有可能是輸入法被砍了，一樣從開始搜索一下 地區及語言

要確定有 中文(台灣) 沒有的話按新增語言，搜索找一下自己新增回來

​