オーバーロードしたメンバ関数が継承後,利用できない

Question

オーバーロードしたメンバ関数のクラスを継承後,そのメンバ関数と同名のメンバ関数を定義すると,オーバーロードしたメンバ関数が呼び出せなくなります.何故でしょうか?

質問を一言で正確に表現できてないと思いますので,状況を順を追って説明します.
まず,クラスT1にメンバ関数m(int)があったとします. そのメンバ関数をオーバーロードしてm(float)を作ったとします. そして,T1を継承してT2を定義し,その中でメンバ関数m(int)をオーバーライドすると,T2のオブジェクトではm(float)が呼び出せなくなってしまいました.

何故この様なことをするかといいますと,m(string)はstringの引数をある関数で変換して整数にしてから,intでm(int)を呼び出しているとします.
T2でも,stringによってm(int)を呼び出すので,T1で定義したm(string)をT2でもそのまま使いたいのです.
例です

class T1{
public:
 virtual void m(int i){cout<<i<<"T1
";}
 void m(string s){m((int)s[0]);}
};
class T2{
public:
 virtual void m(int i){cout<<i<<"T2
";}
};
int main(){
T2 t;
string s("a");
// t.m(s); /*error*/
t.T1::m(s);
}
出力
97T2
T1のm(string)はT2のm(int)を呼び出してます.

何か解決策ありますでしょうか?
また,言語の仕様がこの様になってるのは,この様なことをすると問題があるからだと思うのですが,どのような問題が起こるので禁止されてるのでしょう?
それとも実は,この様なことはできるのでしょうか?
(つまり,単に私のプログラムが間違ってる)

noname#11476 · Accepted Answer

まず用語について、申し訳ありません。
確かに。私が間違って覚えていました。（穴があったら、、、）

さて、ご質問の意図は良くわかりましたが、やはり本質的な問題は多重定義した場合は、そのうち一つでもオーバーライドすると全体が隠されてしまうため、Ｔ３からＴ１のメンバ関数に直接アクセスできない（つまりＴ１のm(const char *)が使えない）ことにありますよね。
結局（多重定義関数は）引数が違うだけでひとまとまりの一つのメンバ関数として扱われているという点です。（そうなっている理由は既に述べたとおりです）

私の思いつく解決策としては、たとえば、

class T1 {
public:
void m(int i) {mm(i);};
void m(char *s){テーブル検索;mm(i);};
protected:
virtual void mm(int i);//mm(int i)にm(i)の処理を移動
};

class T3 : public T1 {
protected:
void mm(int i);
};

と変更する実体の関数を別に用意すれば、そちらはオーバライドされてもかまわないのでこの問題は解決します。
（これがエレガントかといわれると、？？？ですが、、、Ｔ３を作る人にとっては最小限の変更ですみますよね。）
結局のところＴ１クラスに手を入れない、かつT3で(m(string)を）定義しなおさないというと解決策は無いように思えます。

どんなものでしょうか。

個人的にはＴ３でＴ１のm(const char*)を呼び出すm(const char*)を再定義するよりはましかなと思うのですが。
（今回は多重定義一つだから良いけど、１０個くらいあるとそのうち一個の変更のために全部は書きたくないですから）

Ｃ＋＋からこの制約を取り除こうとすると、暗黙の型変換を禁止しないと出来ないように思えますね。
（なぜいっそのこと暗黙の型変換を禁止にしなかったのかは分からないですね。きっといろんな理由があるんでしょうね。）

実のところ、私はテスト的に色々変更する可能性のあるクラスを作るときはよくこの手を使います。
つまり、インターフェース関数はあくまで顔にして実体の関数はprotectedとかprivateに隠してしまう。
こうすると、後でいろんな変更がしやすいんですよね。たとえオーバヘッドがあっても。

noname#30727 · Answer

言葉が足りなかったので、少し追加します。

＞ただ,これだと派生クラスの方で新しく定義したメンバ関数は,呼び出せなくなってしまうという問題がありますね. 

その目的の為に、dynamic_cast というのが後から追加されたのですが、
やや無理矢理的な部分を感じていて、私は積極的には使っていません。

＞それでも,基底クラスのインターフェイスの設計を頑張れば,解決できるような問題かと思えますので,実用的な解決法と言えますね. 

私は、これが C++ の限界と認識しています。
JAVA や C# のような言語では、この問題を一応解決しているのが大きいと思います。

noname#30727 · Answer

＞最後に1つ疑問に思ったのですが,参照による動的結合は可能だったでしょうか? 

わかりやすくする為に、関数を１つあいだにいれますが、

void sub(T1& t){
string s("a"); 
t.m(s);
}

int main(){ 
T1 t1;
T2 t2;
sub(t1);
sub(t2);
return 0; 
}

こんな感じです。

noname#30727 · Answer

解決策ですが、
virtual を使う場合は、基底クラスへのポインタ（もしくは参照）を使ってアクセスするしかないと思います。

int main(){
T1 *t1 = new T1;
T1 *t2 = new T2; // ここが重要
string s("a"); 
t1->m(s);
t2->m(s);
delete t1;
delete t2;
return 0;
}

noname#11476 · Answer

ご質問の内容を理解するために確認します。
ご説明とソースが著しく食い違っているので、ご説明のほうを正としますね。
（ソースコード自体動かないはずです）

class T1 {
public:
　virtual void func(int i);
　virtual void func(float a);
};
というように多重定義したわけですね？（これはオーバーロードではありませんよ）
で、派生クラスを、

class T2 : public T1 {
public:
　void func(char *s);
};

と書いたのですね。
これは、class T2 の T2::func(char *s)　で基底クラスT1の関数 T1::func()をオーバーロード（今度はオーバーロードです）しています。
つまり、基底クラスのT1::funcは再定義されましたので全部見えなくなります。
つまり、
T2 t;
t.func(1);
t.func(1.0);
は T2::func(char *)を呼び出してしまいます。（コンパイルの型チェックで引っかかると思いますが）
基本的にクラスの親子をまたがって「多重定義」は出来ません。（Ｃ＋＋の仕様です。理由はあとで）

解決策はいくつかあります。
１．正攻法
考えてみてください。そもそも派生クラスでそのような同一の働きをする関数を加えることはおかしな話です。
その場合は、普通基底クラスにそのfunc(char *s)を追加すべきなのです。
たとえ基底クラスを変更しても何も問題は起きません。なぜならうまく隠蔽されているからです。

２．邪道１
T2 t;
t.T1::func(1);
t.T1::func(1.0);

はきちんと働きます。（bilboさんのテストがうまくいかなかったのはソースコードに問題があると思いますよ）

３．邪道２
class T2 : public T1 {
public:
　void func(int i) {T1::func(i);};
　void func(float a) {T1::func(a);};
　void func(char *s);
};
と再定義して、T2::func(int i)の中で、T1::func(i)を呼び出せばよい。
ほら、書いてみると分かりますが、これなら初めから基底クラスのT1を変更すべきでしょう。


さて、なぜ派生クラスと基底クラスを含めた多重定義が出来ないのかについて述べますね。
もし、多重定義が出来るとどういうことになるかお話します。

まずＡ君が基底クラス base を作りました。
class base {
public:
　virtual void func(int i);
};

Ｂ君はこれを使って派生クラスderivedを作りました。そして、func2というメンバ関数を作りました。
class derived : public base {
public:
　void func2(double a);
};

さて、Ａ君は色々考えるうちに基底クラスbaseを改良しようと思い、新しい関数を加えることにしました。
そこで、
class base {
public:
　virtual void func(int i);
　virtual void func2(float a);
};
と新しい関数を加えました。もちろんこの関数func2はＢ君が派生クラスで作った関数func2とは異なる働きをします。

ここで問題が発生します。Ａ君は自分の作ったクラスbaseがＢ君によってどのように使われているかは分かっていなかったので、Ｂ君が作った関数と同じ名前で作ってしまったのです。
もし、Ａ君が
　virtual void func2(double a);
と同じ引数であれば、関数はオーバライドされて問題はなかったでしょう。
しかし、この場合は多重定義になりますから、オーバーライドされなかったわけです。

で、Ｂ君のプログラムの中で、

derived foo;
float a;

foo.func2(a);

と呼び出されていたとすると、Ａ君が基底クラスを変更する前であれば、上記プログラムは、
derived::func2(double)
を呼び出していました。（コンパイル時にはワーニングが出ますけどね。エラーではありません。）

しかし、Ａ君が変更した新しいbaseを使うと、なんと！！Ａ君のfunc2を呼び出してしまうではありませんか。
つまり、基底クラスの変更が派生クラスに影響を及ぼしてしまったのです。
こういうことを避けるために、出来ないことになっています。

では。

オーバーロードしたメンバ関数が継承後,利用できない

まず用語について、申し訳ありません。

言葉が足りなかったので、少し追加します。

＞最後に1つ疑問に思ったのですが,参照による動的結合は可能だったでしょうか?

解決策ですが、

ご質問の内容を理解するために確認します。

似たような質問が見つかりました

関連するカテゴリからQ&Aを探す

デイリーランキングこのカテゴリの人気デイリーQ&Aランキング

マンスリーランキングこのカテゴリの人気マンスリーQ&Aランキング