オーバーロード | Programming Place Plus　新C++編

constメンバ関数と非constメンバ関数のオーバーロード

constメンバ関数か非constメンバ関数かという違いだけでもオーバーロードできることは知っておくといいです。

class C {
public:
    // 以下のオーバーロードは OK
    int f();
    int f() const;
};

呼び出し元になるオブジェクトが constオブジェクトなら constメンバ関数版が、そうでないなら非constメンバ関数版が呼び出されます。

constメンバ関数版と非constメンバ関数版を作る事情があるということは、これらの関数はメンバ変数を書き換えることを目的としていないと思われます。メンバ変数を書き換えなければならない仕事を行うなら、constメンバ関数が存在することはあり得ないはずです。一方で、単にメンバ変数の値を出力するだけといったものでもないでしょう。それなら constメンバ関数版だけがあれば事足ります。

このようなオーバーロードを行う目的は、メンバ変数の参照やポインタを返すことである場合が多いです。

class C {
public:
    struct Data {
        int a;
        int b;
        int c;
    };

    Data& get_data()
    {
        return m_data;
    }
    const Data& get_data() const
    {
        return m_data;
    }

private:
    Data m_data;
};

constメンバ関数版では const参照で、非constメンバ関数版では非const の参照で返すようになっています。本来、戻り値だけの違いではオーバーロードできませんが、constメンバ関数・非constメンバ関数という違いがあることによって、これが可能になっています。

ここでは return m_data; の１行だけですが、もしここに記述するコードがもっと長大だったり複雑だったりすると、同じコードの重複が問題になります。あとでどちらか片方だけを修正するというよくあるミスの元です。

同じコードになるなら、別のメンバ関数に共通化すればいいと考えると思いますが、その共通関数を constメンバ関数にも非constメンバ関数にもできません。

class C {
public:
    Data& get_data()
    {
        return common_get_data();
    }
    const Data& get_data() const
    {
        return common_get_data();
    }

private:
    // これが constメンバ関数だったら、非constメンバ関数版の get_data() が返したい Data& を返せない。
    // これが非constメンバ関数だったら、constメンバ関数版の get_data() から呼べない。
    ??? common_get_data() ???
    {
        return /* 複雑なコード */;
    }
};

そこでよく使われる方法は、constメンバ関数版のほうにやりたいコードを書いて、非constメンバ関数版から強引に呼び出すというものです。

class C {
public:
    Data& get_data()
    {
        // constメンバ関数版を呼び出し、戻り値の const を外して返す。
        return const_cast<Data&>(static_cast<const C*>(this)->get_data());
    }
    const Data& get_data() const
    {
        return /* 複雑なコード */;
    }
};

非constメンバ関数版がやっていることはこうです。

1. *this を constオブジェクトにするため、static_cast で this を constポインタにする
2. 1 で得たポインタを使って同名のメンバ関数を呼ぶことで、constメンバ関数版を呼び出す
3. 返された結果（const Data&）から const を取り外すため、const_cast を行う
4. 3 で得た結果を返す

非constメンバ関数版の本体では、thisポインタは C* という型ですから、そのまま get_dataメンバ関数を呼び出すと、自分自身を呼び出す結果になってしまいます。constメンバ関数版を呼び出すには、強引に自分自身を const にしてしまえばよく、そのために this を const C* にキャストしています（*this を const C& にすることでも可能です）。このキャストは static_cast で行えます（このあと登場する const_cast でも可能）。

constメンバ関数が返す結果は const が付加された const Data& という型ですから、非constメンバ関数が返したい Data& にするためには const を取り外す必要があります。参照やポインタの const は const_cast で取り外せます。const_cast の文法は static_cast や reinterpret_cast（「配列とポインタ」のページを参照）と同様です。

const_cast<型>(式)

const_cast は、参照やポインタについている const や volatile（未解説）を取り外したり、付加したりできます。これ以外の場面で登場する const を操作することはできません。

const を取り外してしまうことに不安を感じるかもしれませんが、もともと、非constメンバ関数版を呼び出すことからスタートしているので、このオブジェクトが書き換えられる可能性は想定内といえます。意外にもこの方法は基本的に安全です。

【上級】とはいえ const_cast は必要悪のようなもので、できれば避けたい方法ではあります。代わりの方法として、メンバ関数テンプレートにコードを共通化する方法があります。²

名前探索を行い、候補関数を探す

名前探索 (name lookup) は、ソースコード上で使用されている名前が、実際には何を意味したものなのかを決定することをいいます。名前探索自体も相当に複雑なので⁴、これについても概要だけ示すことにします。

名前探索のルールは、スコープ解決演算子(::) による修飾を行っているかどうかによって異なります。

スコープ解決演算子で修飾されている名前に対する名前探索は、修飾の名前探索 (qualified name lookup) と呼ばれます。この場合、:: の左側に記述したクラス、名前空間、scoped enum から該当する名前を探索します。:: の左側に何もない場合はグローバル名前空間から探索します。

スコープ解決演算子で修飾されていない名前に対する名前探索は、非修飾の名前探索 (unqualified name lookup) と呼ばれます。この場合、その名前が使われている場所から発見できる名前を探索します。usingディレクティブ（「スコープと名前空間」のページを参照）や using宣言（「スコープと名前空間」のページを参照）の効力の影響を受けます。

非修飾の名前探索には、実引数依存の名前探索 (ADL: Argument Dependent name Lookup) と呼ばれる更なるルールが存在します。これは、関数呼び出しの際、その関数を探すときには、実引数に指定した内容も考慮に加えるというものです。たとえば、f(T x); のように関数f を呼び出すとき、この呼び出しが記述されている場所から見えている f だけでなく、型T が所属している名前空間も探索範囲に加えるということです。

namespace n1 {
    struct T {
        int a;
        int b;
    };
    void f(T x);
}

namespace n2 {
    void g()
    {
        n1::T x {};
        f(x);  // OK. x が n1::x であることから、n1 も探索し、n1::f を見つける
    }
}

こうした名前探索を行った結果、いくつかの関数を見つける可能性があります。これらの関数のことを候補関数 (candidate functions) と呼びます。

候補関数は名前の一致は確認されていますが、その関数が呼び出し可能であるかどうかを考慮していません。たとえば、以下のような関数であっても候補関数には選ばれます。

• 実引数と仮引数の対応が取れていない
• 宣言はあるが、定義が存在していない
• private と指定されているメンバ関数をクラスの外から見つけた
• =delete で削除された関数である（「静的メンバ」のページを参照）

候補関数を１つ以上発見できた場合は、実行可能関数を絞り込むステップへ進みます。候補関数が１つも発見できなければ、使おうとしている名前が何であるのか決定できないため、コンパイルエラーとなります。

実行可能関数を絞り込む

候補関数の中から、実際に呼び出せる関数、つまり実行可能関数 (viable functions) を絞り込みます。

「viable functions」に対する訳語には、有効な関数、適切関数、妥当な関数などさまざまあります。

まず、仮引数の個数に対して、実引数の個数が十分であるかを調べます。その結果、以下のいずれかを満たしていれば、次の判断に進むことができます。満たさなければ実行可能関数ではありません。

• 個数が一致している
• 実引数のほうが多いが、仮引数には ... がある（未解説の機能）
• 実引数のほうが少ないが、実引数より多い部分の仮引数にデフォルト実引数がある

【Ｃ言語プログラマー】... は printf関数などでおなじみの可変個引数のことです。

次に、実引数が、対応する仮引数の型と一致する、あるいは暗黙に型変換できるかどうかを調べます。型を一致させられるのであれば実行可能関数とみなされ、そうでなければ実行可能関数ではありません。

実行可能関数が１つだけであれば、その関数がオーバーロード解決の結果となります。複数の実行可能関数が残った場合は次のステップへ進んで１つに定めます。実行可能関数がなければコンパイルエラーです。

最適な実行可能関数を絞り込む

実行可能関数の中から、最もふさわしい関数を１つに定めます。ここで選ばれる関数を、最適な実行可能関数 (best viable functions) と呼びます。

基本的な考え方としては、実引数の型が、仮引数の型にどれだけ近いかを比較し、最も近しい関数が選び出されるということです。引数が複数あることもありますから、第１引数なら一方の関数のほうが近くても、第２引数では他方の関数のほうが近くて、同点と言わざるをえない場合もあります。そのような場合、最適な実行可能関数が１つに定めきれず、曖昧であるという主旨のコンパイルエラーになります。

型が完全に一致していれば、もっとも近いといえます。

void f(int a, int b);
void f(int a, double b);

f(100, 0);  // f(int, int) と完全一致。これが選ばれる

暗黙の型変換の内容が同じであるなら、それが必要な引数が少ない方が近いといえます。

void f(int a, int b, long c);
void f(int a, long b, long c);

f(0, 0, 0);  // f(int, int, long) は int -> long の型変換が１つだけ必要。これが選ばれる
             // f(int, long, long) は int -> long の型変換が２つ必要。

この例で、２つ目の関数f の第３引数が int であったら、暗黙の型変換が必要な個数が同じになるため、どちらがより一致しているとはいえず、コンパイルエラーになります。

void f(int a, int b, long c);
void f(int a, long b, int c);

f(0, 0, 0);  // f(int, int, long) も f(int, long, int) も、
             // int -> long の型変換が２つ必要なため曖昧である

また、暗黙の型変換は以下のように分類できます。

1. 標準の型変換
2. ユーザー定義の型変換
3. エリプシス変換

上にあるものほど優先されます。つまり上にある型変換を使っているもののほうが、より近しい関数であると判定されます。

標準の型変換 (standard conversion) は、C++ の標準機能として備わっている暗黙の型変換のことです⁵。int から long や、double から int などはここに含まれます。

ユーザー定義の型変換 (user-defined conversion) は、プログラマーが明示的に定義した型変換のことです。変換コンストラクタ（「コンストラクタ」のページを参照）や、変換関数（後述 TODO ）が該当します⁶。

エリプシス変換 (ellipsis conversion) は、仮引数が ... となっている場合に行われる型変換のことです（これは未解説の機能です）。

添字演算子

まずは比較的分かりやすい添字演算子からみていきます。以下の演算子です。

[]

添字演算子は、配列の要素へのアクセスに用いる演算子でした。添字演算子をオーバーロードすることで、自作のクラスを配列のように取り扱えるようになります。std::vector や std::string で [] が使えているのは、添字演算子がオーバーロードされているからです。

添字演算子のオーバーロードは、必ず非静的なメンバ関数として行います。仮引数を必ず１つ持たせなければなりません。a[3] のような使い方をしたとき、3 の部分が仮引数に渡されてきます。一般的な添字のイメージからいって、仮引数は整数型が自然に思えるかもしれませんが、型に制約はありません。

特に、添字に文字列を用いる配列は連想配列と呼ばれ、よく使われるデータ構造の一種です。

以下は使用例です。

#include <iostream>

class C {
public:
    C() : mValues {}
    {}

    inline const int& operator[](std::size_t index) const
    {
        return mValues[index];
    }
    inline int& operator[](std::size_t index)
    {
        return mValues[index];
    }

private:
    int    mValues[100];
};

int main()
{
    C c {};
    c[1] = 100;
    std::cout << c[1] << "\n";
}

実行結果：

100

constメンバ関数版と、非constメンバ関数版を作っています。c[1] = 100 のような書き込みのアクセスを行うためには非constメンバ関数版が必要ですし、const なオブジェクトから要素の値を読み取るには、constメンバ関数版が必要です。

また、戻り値の型は参照型にします。c[1] = 100 という式は、c.operator[](1) = 100 を意味しますから、戻り値に対して代入が行える必要があるためです。

単項演算子

続いて単項演算子です。

+   -   *   &   |   ~

+、-、*、& には二項演算子のものも存在しますが、それらは二項演算子のルールに従います。

単項演算子をオーバーロードする方法は２つあります。１つは静的でないメンバ関数にする方法、もう１つは非メンバ関数にする方法です。

静的でないメンバ関数にする方法では、そのクラス型のオブジェクトに対して演算子を使うと、そのメンバ関数が呼び出されます。

#include <iostream>

class DataStore {
public:
    explicit DataStore(int v) : mValue {v}
    {}

    inline operator int() const
    {
        return mValue;
    }

    inline DataStore operator+() const
    {
        return *this;
    }
    DataStore operator-() const;

private:
    int    mValue;
};

DataStore DataStore::operator-() const
{
    DataStore tmp {-mValue};
    return tmp;
}

int main()
{
    DataStore ds {123};
    std::cout << +ds << "\n"; 
    std::cout << -ds << "\n"; 
}

実行結果：

123
-123

//TODO: 非メンバ関数版

戻り値の型 operator 演算子(仮引数);

二項演算子

代入演算子

関数呼び出し演算子

クラスメンバアクセス演算子

インクリメント演算子、デクリメント演算子

new演算子、delete演算子

たとえば、+ という演算子に、２つの色を足し合わせるオーバーロードを追加するなら次のように記述します。

#include <algorithm>
#include <iostream>

struct Color {
    unsigned char  red;
    unsigned char  green;
    unsigned char  blue;
};

Color operator + (const Color& lhs, const Color& rhs)
{
    int red {lhs.red + rhs.red};
    int green {lhs.green + rhs.green};
    int blue {lhs.blue + rhs.blue};

    return {
        static_cast<unsigned char>(std::min(red, 255)),
        static_cast<unsigned char>(std::min(green, 255)),
        static_cast<unsigned char>(std::min(blue, 255)),
    };
}

int main()
{
    Color color1 {0, 150, 255};
    Color color2 {100, 150, 255};
    Color new_color {color1 + color2};  // OK

    std::cout << static_cast<int>(new_color.red) << " "
              << static_cast<int>(new_color.green) << " "
              << static_cast<int>(new_color.blue) << "\n";
}

実行結果：

100 255 255

演算子関数