重載雙下標 operator[][] 的方法

重載雙重下標 operator[][] 的方法

tags: C++ Concept

一般而言 operator[] 只能重載一次，因為第一次的指標就已經指向元素了，不可能再讓元素去呼叫 operator[] 除非是二維陣列還能夠在做一次呼叫

需要透過一些技巧來實現雙下標這個功能，主要最主要的差別是

Arr a;
a[0];   // 一維存取
a[0][0] // 二維存取

不過這種語意可能很容易讓人誤會，比如說如果是三維陣列的話就沒辦法區分這種方式的重載了。

最關鍵的技巧在於需要重載的 operatoe[] 要返回第二個類別，利用這個類別來重載第二個 operatoe[] ，並重載第二個類別的 operatoe T& ，即便只有單一個下標返回的類別也能夠正確的傳回元素。

參考代碼：

/*****************************************************************
Name : 
Date : 2017/03/18
By   : CharlotteHonG(整理)
Final: 2017/03/18

原文：https://www.ptt.cc/bbs/C_and_CPP/M.1478167551.A.5ED.html
原始代碼：http://ideone.com/Tm4Bgk
*****************************************************************/
#include <iomanip>
#include <iostream>
#include <numeric>
#include <vector>
using namespace std;

template<class T>
class Middle {
public:
    using size_type=typename vector<T>::size_type;
public:
    // 建構子
    Middle(vector<T> &vec, const size_type column, 
        const size_type index) noexcept
        :vec_{addressof(vec)}, column_{column}, index_{index}{}
    // 複製建構子
    Middle(const Middle &) = default;
public:
    // 取址函式
    operator T&(){
        return (*vec_)[index_];
    }
    // 複製函式
    Middle& operator=(const Middle &) = delete;
    void operator=(T const & data){
        (*vec_)[index_] = move(data);
    }
    // 重載下標
    T& operator[](const size_t i){
        return (*vec_)[index_*column_+i];
    }
private:
    vector<T> *vec_;
    const size_type column_;
    const size_type index_;
};

template<class T>
class Const_Middle {
public:
    using size_type=typename vector<T>::size_type;
public:
    // 建構子
    Const_Middle(const vector<T> &vec, const size_type column, 
        const size_type index) noexcept
        :vec_{addressof(vec)}, column_{column}, index_{index}{}
    // 複製建構子
    Const_Middle(const Const_Middle &) = default;
public:
    // 取址存取
    operator const T&(){
        return (*vec_)[index_];
    }
    // 複製函式
    Const_Middle& operator=(const Const_Middle &) = delete;
    // 重載下標
    const T& operator[](const size_t i){
        return (*vec_)[index_*column_+i];
    }
private:
    const vector<T> *vec_;
    const size_type column_;
    const size_type index_;
};

template<class T>
class Test {
public:
    using size_type=typename vector<T>::size_type;
public:
    // 建構子
    Test(const size_type row,const size_type column)
        :vec_(row*column), column_{column}{}
    Test const& pri() const{
        for(unsigned j = 0; j < vec_.size()/column_; ++j) {
            for(unsigned i = 0; i < column_; ++i) {
                cout << vec_[j*column_ + i] << ", ";
            } cout << endl;
        } cout << endl;
        return (*this);
    }
public:
    // 重載下標
    Middle<T> operator[](const size_t i){
        return Middle<T>{vec_,column_,i};
    }
    Const_Middle<T> operator[](const size_t i) const{
        return Const_Middle<T>{vec_,column_,i};
    }
public:
    vector<T> vec_;
private:
    const size_type column_;
};

int main(int argc, char const *argv[]){
    // 初始化
    Test<int> test(3, 4);
    iota(begin(test.vec_), end(test.vec_), 0);
    const Test<int> & test2 = test;
    // 測試
    test.pri();
    test[0][0] = 7;
    test[1] = 7;
    test.pri();
    test2.pri();
}

參考：[問題] 重載[][] 下標運算子(架構已定)

​

operator=() 進階重載，具2種或多種語意重載

tags: C++ Concept

除了一般重載等號之外，如果你想做不同的操作，比如說你希望在指定單一元素的時候可以用等號做存取

Raw a(4, 4);

假設這是一張4x4總共16格的一維陣列

a[0] = -1;

你可以透過下標的等號直接存取

a.at2d(0, 1) = -1;

也可以透過函式進行二維模式的存取

// 區塊等號賦值
a.blk(2) = a.blk(3);

甚至可以在不影響原本運算子的情況下進型區塊複製
區塊指的是以4個單位為一組計算，全部16個可以分成4組
最左上4個為0，最右下4個為3

// 不影響原本的等號
Raw b(4, 4);
a=b;

仍然是預設複製運算子，複製所有資源

用途

這在某些複雜的運算上，可以很大的程度的減少代碼量與程式設計難度
只不過效能上可能多少有些損耗。

參考代碼：

/*****************************************************************
Name : 
Date : 2017/03/21
By   : CharlotteHonG
Final: 2017/03/21
*****************************************************************/
#include <iostream>
#include <iomanip>
#include <vector>
#include <numeric>
#include <cmath>
#include <typeinfo>
using namespace std;

class Raw {
public:
    Raw(size_t y, size_t x): col(x), img(y*x){
        iota(img.begin(), img.end(), 1);
    }
public: // 運算子
// 重載下標符號
int & operator[](size_t idx){
    return const_cast<int&>(static_cast<const Raw&>(*this)[idx]);
}
const int & operator[](size_t idx) const{
    return img[idx];
}
int & at2d(size_t y, size_t x){
    return const_cast<int&>(
        static_cast<const Raw&>(*this).at2d(y, x));
}
const int & at2d(size_t y, size_t x) const{
    return (*this)[y*col+x];
}
public: // 基礎函式
void info(){
    for(unsigned j = 0; j < img.size()/col; ++j) {
        for(unsigned i = 0; i < col; ++i) {
            cout << setw(3) << img[j*col+i];
        }cout << endl;
    }cout << endl;
}
void get_block(size_t h, size_t w);
private:// 資料成員
    size_t col;
    vector<int> img;
private:
    class Block;
    vector<Block> blk_p;
public:
    Block blk(size_t pos);
};

// 轉介的類別
class Raw::Block{
public:
    #define BlkSize 4 // 區塊大小
    Block(): p(BlkSize){}
    Block(Raw & img, size_t pos): p(BlkSize){
        size_t Sidelen = sqrt(BlkSize);
        // 取得對應位置
        size_t pos_y=((pos/((img.img.size())/img.col/Sidelen))*Sidelen);
        size_t pos_x=((pos%(img.col/Sidelen))*Sidelen);
        // 複製指標
        for(unsigned j=0, c=0; j < Sidelen; ++j)
            for(unsigned i = 0; i < Sidelen; ++i, ++c)
                p[c] = &img.at2d(pos_y+j, pos_x+i);
    }
    // 深層拷貝
    Block & operator=(Block const & rhs){
        cout << "C &" << endl;
        if (this == &rhs)
            return (*this);
        for (unsigned i = 0; i < p.size(); ++i)
            *(p[i]) = *(rhs.p[i]);
        return (*this);
    }
    // 淺層拷貝
    Block & copy(Block const & rhs){
        if (this == &rhs){
            return (*this);
        } else {
            p = rhs.p;
        } return (*this);
    }
    Block & copy(Block && rhs){
        if (this == &rhs){
            return (*this);
        } else {
            p = std::move(rhs.p);
        } return (*this);
    }
    void info(){
        for(auto&& i : p) {
            cout << setw(3) << *i ;
        }cout << endl;
    }
public:
    vector<int*> p;
};
auto Raw::blk(size_t pos)-> Block{
    return Block((*this), pos);
}

void Raw::get_block(size_t h=2, size_t w=2){
    size_t len = (img.size()/col/h) * (col/w);
    // cout << "len=" << len << endl;
    this->blk_p.resize(len);
    // blk_p 預載 len 個區塊
    for (unsigned i = 0; i < len; ++i){
        this->blk_p[i].copy( Block((*this), i) );
        // this->blk_p[i].info();
    }
}

/*==============================================================*/
int main(int argc, char const *argv[]){
    Raw a(4, 4);
    a.info();
    // 一般等號賦值
    a[0] = -1;
    a.at2d(0, 1) = -1;
    a.info();
    // 區塊等號賦值
    a.blk(2) = a.blk(3);
    a.info();
    return 0;
}
/*==============================================================*/

​

盡可能的為你的程式設計空建構子

tags: C++ Concept

在某些情況下沒有空的建構子可能會導致很難尋找的錯誤，比如說Vector的初始化。

/*****************************************************************
Name : 
Date : 2017/03/21
By   : CharlotteHonG
Final: 2017/03/21
*****************************************************************/
#include <iostream>
#include <vector>
using namespace std;

class ClassB{
public:
    ClassB(int i){}
};

class ClassA {
public:
    ClassA(){
        // i.resize(1); // Error
    }
public:
    vector<ClassB> i;
};
/*==============================================================*/
int main(int argc, char const *argv[]){
    ClassA a;
    return 0;
}
/*==============================================================*/

上述代碼因為沒有空建構子導致 vector 初始化，或調整長度時出問題

ClassB(int i=1){}
ClassB(){}

補上空的建構子或是具有預設數值的引入參數

​

兩個 結構、類別 交錯互相使用對方的資源

tags: C++ Concept

如何讓兩個 結構、類別 交錯互相使用對方的資源，並拆開定義將檔案拆檔。

完全隱藏類別

使用 inner class 這樣交錯的結構，可以完全隱藏你不想公開的類別

class Fa {
private:
    class Son{
        Son(Fa const &);
    }
    Son data;
};

如果使用 friend 則勢必要將結構公開，你可以使用 private 隱藏，但相對的會佔用一個 class 名稱。

會遇到的問題

如果將定義移動至外面會導致定義不完全出現
field '' has incomplete type ''

資料成員

class Fa {
private:
    class Son;
    Son data;
};

class Fa::Son{

};

因為 Son data; 找不到該目標的實作無法初始化
解決辦法先不要實作利用 指標 或 vector 規避

class Fa {
private:
    class Son;
    vector<Son> data;
    Son* data2;
};

class Fa::Son{

};

副函式

定義副函式的時候也會出現這個問題

class Fa {
private:
    class Son;
    Son fun(size_t pos){}
};

class Fa::Son{

};

返回的數值 Son fun(size_t pos){} 用到了 Son ，一樣找不到該實作的定義。
解決辦法將 fun() 的定義移出至宣告後先不要讓他實做

class Fa {
private:
    class Son;
    Son fun(size_t pos);
};
class Fa::Son{};

Fa::Son Fa::fun(size_t pos){}

可能發生的問題

這裡有一個小坑， Son 必須定義空建構子或是帶有預設數值的引入參數，否則會導致 vector 無法初始化。

示例代碼

未拆開

/*****************************************************************
Name : 類別的互相交錯實作
Date : 2016/12/09
By   : CharlotteHonG
Final: 2017/03/23
*****************************************************************/
#include <iostream>
using namespace std;

struct Fa{
    Fa(string name):name(name){}

    struct Son{
        Son(string name, Fa* fa):name(name), fa(*fa){}
        void fa_name(){
            cout << "My fa = " << this->fa.name << endl;
        }
        string name;
        Fa& fa;
    };

    Son cre_son(string name){
        Son temp(name, this);
        this->son = &temp;
        return temp;
    }

    void son_name(){
        cout << "My son = " << (*son).name << endl;
    }

    string name;
    Son* son;
};

using Son=Fa::Son;
/*=======================================================*/
int main(int argc, char const *argv[]){
    Fa John("John");
    Son Job = John.cre_son("Job");
    // Fa 裡面有 Son ， Son 又可以存取 Fa
    Job.fa_name();
    John.son_name();
    return 0;
}
/*=======================================================*/

拆開定義

/*****************************************************************
Name : 類別的互相交錯實作
Date : 2016/12/09
By   : CharlotteHonG
Final: 2017/03/23
*****************************************************************/
#include <iostream>
using namespace std;
// 主類別的宣告
struct Fa{
    Fa(string name):name(name){}

    struct Son;
    Son cre_son(string name);
    void son_name();

    string name;
    Son* son;
}; using Son=Fa::Son;
// 內類別的定義
struct Fa::Son{
    Son(string name, Fa* fa):name(name), fa(*fa){}
    void fa_name();
    string name;
    Fa& fa;
};
// 內類別的函式定義
void Son::fa_name(){
    cout << "My fa = " << this->fa.name << endl;
}
// 主類別的函式定義
Son Fa::cre_son(string name){
    Son temp(name, this);
    this->son = &temp;
    return temp;
}
void Fa::son_name(){
    cout << "My son = " << (*son).name << endl;
}
/*=======================================================*/
int main(int argc, char const *argv[]){
    Fa John("John");
    Son Job = John.cre_son("Job");
    // Fa 裡面有 Son ， Son 又可以存取 Fa
    Job.fa_name();
    John.son_name();
    return 0;
}
/*=======================================================*/

​

引入參數如何區分左值與右值

tags: C++ Concept

右值大原則

• 大原則他 沒有名字
• 只能放置在等號右邊，不能夠放置在等號左邊(不能賦值)

int val(){
    return 0;
}

int i=0;   // 名字是i
val();     // 名字?
val()=0;   // Error

主程式引入處

一般而言如果直接定義，那麼他將是個右值

fun(1);

如果是一個已經被定義的變數，已經具有名字可以使用move()轉為右值

int i = 1;
fun(std::move(i));

副程式引入參數

只有左值

void fun(int & i){
    cout << "l only" << endl;
}

只有右值

void fun(int const && i){
    cout << "r only" << endl;
}

左右值通吃(低優先權)

void fun2(int const & i){
    cout << "l or r" << endl;
}

副程式返回參數

因為返回的參數都是沒有名字的，所以都會是右值

int val(){
    return 0;
}

int i = val();
val() = 1; // Error

範例代碼

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

void fun(int & i){
    cout << "l only" << endl;
}
void fun(int const && i){
    cout << "r only" << endl;
}

void fun2(int const & i){
    // 如果有其他限定左右直的函式則他們優先
    cout << "l or r" << endl;
}

int val(){
    return 0;
}
/*==============================================================*/
int main(int argc, char const *argv[]){
    int i(0);
    // fun1
    fun(i);
    fun(move(i));
    fun(val());
    // fun2
    fun2(i);
    fun2(move(i));
    fun2(val());

    return 0;
}
/*==============================================================*/

​