1. Universal Referenceの
オーバーロードは避けよう
2015/06/17 EMC++勉強会
西村 章宏 @Regenschauer490

2. 概要
• 汎用的で効率面で無駄のない関数を実現するには、
universal referenceが便利
• 後から特殊化された処理を加えようとして、関数
オーバーロードを行うと思わぬ落とし穴
• Perfect forwarding なコンストラクタが基底クラスに
ある場合、継承時に思わぬ落とし穴

3. 例：フリー関数
• 引数に文字列を渡したい場合
– 名前を引数に取り、ログを追加する関数を考える
• 単純に考えると、次の様な関数が思い浮かぶ
• このコードは悪くはないが、効率的ではない
std::multiset<std::string> names;
void logAndAdd( const std::string& name)
{
…
names.emplace(name);
}

4. 例：フリー関数
– 呼び出し側で渡される文字列の型は3種類考えられる
1. lvalue std::string
2. rvalue std::string
3. 文字列リテラル
std::string petName(“Darla”);
logAndAdd( petName ); // 1
logAndAdd( std::string(“Persephone”) ); // 2
logAndAdd( “Patty Dog” ); // 3

5. 例：フリー関数
– ログ(names)に渡されるまでの過程
1. lvalue std::string
① petNameを作成
② nameをpetNameにバインド (非コピー)
③ namesにnameが渡され、内部でコピー
std::string petName(“Darla”);
logAndAdd( petName );
void logAndAdd( const std::string& name)
{
…
names.emplace(name);
}

6. 例：フリー関数
– ログ(names)に渡されるまでの過程
2. rvalue std::string
① 一時的なstd::stringを作成
② nameを一時変数にバインド (非コピー)
③ namesにnameが渡され、内部でコピーされる
 name自体はlvalueなのでmoveされない
logAndAdd( std::string(“Persephone”) );
void logAndAdd( const std::string& name)
{
…
names.emplace(name);
}

7. 例：フリー関数
– ログ(names)に渡されるまでの過程
3. 文字列リテラル
① nameを”Pretty Dog”にバインドする際、暗黙的に
一時的なstd::stringを作成
② namesにnameが渡され、内部でコピーされる
 name自体はlvalueなのでmoveされない
logAndAdd( “Patty Dog” );
void logAndAdd( const std::string& name)
{
…
names.emplace(name);
}

8. 例：フリー関数
– logAndAdd関数の効率面での問題点
1. lvalue std::string ： 特になし
2. rvalue std::string ： moveできるのにコピーされている
3. 文字列リテラル ： emplaceに文字列リテラルをそのまま
渡せるのに一時変数が作られ、それが
コピーされている
std::string petName(“Darla”);
logAndAdd( petName );
logAndAdd( std::string(“Persephone”) );
logAndAdd( “Patty Dog” );
void logAndAdd( const std::string& name)
{
…
names.emplace(name);
}

9. 例：フリー関数
– universal referenceを使えば解決できるかも！
1. lvalue std::string ： 変更前と同じ (T&& -> std::string&)
2. rvalue std::string ： perfect forwarding (T -> std::string)
3. 文字列リテラル ： 文字列リテラルのままemplaceに渡さ
れる (T&& -> const char (&)[10] )
std::string petName(“Darla”);
logAndAdd( petName );
logAndAdd( std::string(“Persephone”) );
logAndAdd( “Patty Dog” );
template <typename T>
void logAndAdd( T&& name)
{
…
names.emplace(std::forward<T>(name));
}

10. Universal Referenceで解決
– 解決ｩ！ 第26章完！
– …もし別の型でログを追加する必要が生じた場合
• indexを引数に取り、対応する名前を検索してログを追加する
関数を想定
• int型を引数に取るオーバーロードを定義
void logAndAdd(int idx)
{
…
names.emplace( nameFromIndex(idx) );
}

11. Universal Referenceとオーバーロード
– 意図通りのオーバーロード解決にはならない
• short型変数からは、T&&の関数が呼び出されてしまう
• T&&の関数内で、emplaceはshort型に対するオーバー
ロードは存在しないのでエラーとなる
std::string petName(“Darla”);
short nameIdx;
logAndAdd( petName ); // invoke T&& overload
logAndAdd( std::string(“Persephone”) ); // invoke T&& overload
logAndAdd( “Patty Dog” ); // invoke T&& overload
logAndAdd( 22 ); // call int overload
logAndAdd( nameIdx ); // error!

12. オーバーロード解決
• 原則として、引数が最もマッチする関数が選択される
 大まかな優先順位は以下の通り
1. 非関数templateで、引数が最もマッチする関数
2. 関数templateで、template argument deductionにより
1と同じシグネチャになる関数
3. 暗黙的変換を行うとマッチする関数
(変換の種類の中にも3段階の優先順位あり)

13. オーバーロード解決
– 例
void f(short v); // 優先順位1 (非template, 無変換)
template <class T>
void f(T& v); // 優先順位2 (template, 無変換)
void f(short const& a); // 優先順位3 (非template, qualification conversion)
template <class T>
void f(T const& v); // 優先順位4 (template, qualification conversion)
void f(int v); // 優先順位5 (非template , integral promotion)
void f(double v); // 優先順位6 (非template, floating-integral conversion)
int main(){
short a = 1;
f(a);
}

14. 例：コンストラクタ
• logAndAdd関数に似た機能をコンストラクタで実装したい
– perfect forwarding なコンストラクタを考える
• 一見、コンストラクタは2種類しか存在しないように見える
• templateコンストラクタは、コピー・ムーブコンストラクタの
自動生成の妨げとはならない
class Person
{
template<typename T>
explicit Person( T&& name );
explicit Person( int idx );
}

15. 例：コンストラクタ
– perfect forwarding なコンストラクタを考える
• コピー・ムーブコンストラクタが自動生成される
• 下記4種類の中からオーバーロード解決が行われる
class Person
{
template<typename T>
explicit Person( T&& name );
explicit Person( int idx );
Person( const Person& rhs );
Person( Person&& rhs );
};

16. 例：コンストラクタ
– フリー関数の場合と同様、意図通りには動かない
• 下例ではコピーコンストラクタが呼ばれて欲しいが…
• この例では、T&& はインスタンス化されると Person& となる
• pは非const修飾であるため、コピーコンストラクタのシグネ
チャとマッチするためにはqualification conversionが必要
• よって、変換が不要なT&&の方が優先順位は高くなる
Person p(“Nancy”); // invoke T&& ctor
auto cloneOfp(p); // invoke T&& ctor ( not copy ctor )
※const Person p(“Nancy”); と定義すると、copy ctorが呼ばれる

17. 例：コンストラクタ
– 継承が絡んでくると更に酷いことに
• rhsは “SpecialPerson”型なので、PersonクラスのT&&は
– copy ctor (上)： T&& -> const SpecialPerson&
– move ctor (下)： T&& -> SpecialPerson&&
• SpecialPerson& から Person& へは reference conversion が必要
class SpecialPerson : public Person
{
SpecialPerson( const SpecialPerson& rhs)
: Person(rhs); // calls Person’s T&& ctor
SpecialPerson( SpecialPerson&& rhs)
: Person(std::move(rhs)); // calls Person’s T&& ctor
};

18. 教訓
• Universal referenceはインスタンス化されると
ほとんど全ての型(+修飾子)を表現できる
Item24参照
例外はItem30で説明
• オーバーロード解決では、 我々が予想する以上に
universal referenceの方を呼び出されることが多い
• Perfect forwarding なコンストラクタは特に問題があり、
もし基底クラスに存在すれば基底クラスのコピー・ムーブ
コンストラクタを乗っ取ってしまう