C++のコードをヘッダに書くか、ソースに書くかについて

Question

実現したいこと

• C++の実行コードをヘッダに書くか、ソースに書くかについて、皆さんのご意見をうかがいたい
• 例えば「自分はベストプラクティスを知っているので広めたい！」という意見
• 例えば「自分はこういうケースでいつもこうしている」という意見
• 例えば「自分はよく知らないけど、こういうツールを知っている」という意見
• etc...

前提

• C++11(以降)
• 公開範囲については皆さんが想定されるケースを決めてください(言及しない場合はオープンソース)
• 規模感については皆さんが想定されるケースを決めてください(言及しない場合は数k行程度以内)
• 外部コードの有無については、皆さんが想定されるケースを決めてください(言及しない場合は自身がアプリから使用されるライブラリ)
• 処理系についてはgcc9以降限定
• プラットフォームについては限定しませんが、OSはあるものとしてください

発生している問題・エラーメッセージ

• (A)ヘッダに書く場合は、公開したくないコードまで公開する必要がある
• (B)ソースに書く場合は、テンプレートのインスタンス化が悩ましい
• (C)ヘッダに書く場合は、同じものが複数展開されるため、それぞれでコードが異なりうる懸念がある

(B),(C)については以下コードで例示します

該当のソースコード

環境構築用のスクリプトです。最後にビルドして実行します。

#!/bin/sh
cat >Makefile <<EOF
CC=g++
CXXFLAGS=-g -std=c++11 -Wall
all: main main_lib main_diff
clean:
        rm -f *.o *.a main main_lib main_diff
main: main.o
main_lib: main_lib.o libsub.a
        \$(CC) main_lib.o -L. -lsub -o main_lib
libsub.a: libsub.a(sub_lib.o)
main_diff: main_diff.o libsub2.a
        \$(CC) main_diff.o -L. -lsub2 -o main_diff
main_diff.o: main_diff.cpp sub_diff_v1.h
        cp sub_diff_v1.h sub_diff.h
        \$(CXX) \$(CXXFLAGS) \$(CPPFLAGS) \$(TARGET_ARCH) -c main_diff.cpp
sub2_diff.o: main_diff.cpp sub_diff_v2.h
        cp sub_diff_v2.h sub_diff.h
        \$(CXX) \$(CXXFLAGS) \$(CPPFLAGS) \$(TARGET_ARCH) -c sub2_diff.cpp
libsub2.a: libsub2.a(sub2_diff.o)
EOF
cat >main.cpp <<EOF
#include <iostream>
#include "sub.h"
int main() {
    Hoge hoge;
    hoge.print(std::cout);
    return 0;
}
EOF
cat >main_diff.cpp <<EOF
#include <iostream>
#include "sub_diff.h"
#include "sub2_diff.h"
int main() {
    Hoge hoge;
    hoge.print(std::cout);
    sub2();
    return 0;
}
EOF
cat >main_lib.cpp <<EOF
#include <iostream>
#include "sub_lib.h"
int main() {
    Hoge hoge;
    hoge.print(std::cout);
    return 0;
}
EOF
cat >sub.h <<EOF
#pragma once
#include <ostream>
struct Hoge {
    template<typename T> void print(T& out) { out << "ほげ" << std::endl; }
};
EOF
cat >sub2_diff.cpp <<EOF
#include <iostream>
#include "sub_diff.h"
#include "sub2_diff.h"
void sub2() {
    Hoge hoge;
    hoge.print(std::cout);
}
EOF
cat >sub2_diff.h <<EOF
#pragma once
void sub2();
EOF
cat >sub_diff.h <<EOF
#pragma once
#include <ostream>
struct Hoge {
    template<typename T> void print(T& out) { out << "ふが" << std::endl; }
};
EOF
cat >sub_diff_v1.h <<EOF
#pragma once
#include <ostream>
struct Hoge {
    template<typename T> void print(T& out) { out << "ほげ" << std::endl; }
};
EOF
cat >sub_diff_v2.h <<EOF
#pragma once
#include <ostream>
struct Hoge {
    template<typename T> void print(T& out) { out << "ふが" << std::endl; }
};
EOF
cat >sub_lib.cpp <<EOF
#include <ostream>
#include "sub_lib.h"
template<typename T>
void Hoge::print(T& out) {
    out << "ほげ" << std::endl;
}
template void Hoge::print(std::ostream&);
EOF
cat >sub_lib.h <<EOF
#pragma once
struct Hoge {
    template<typename T> void print(T& out);
};
EOF
make
./main
./main_lib
./main_diff

(B)/(C)の説明

まずは基本となるmain.cppとsub.hを見てください。

main.cpp

#include <iostream>
#include "sub.h"
int main() {
    Hoge hoge;
    hoge.print(std::cout);
    return 0;
}

sub.h

#pragma once
#include <ostream>
struct Hoge {
    template<typename T> void print(T& out) { out << "ほげ" << std::endl; }
};

何の変哲もない「ほげ」って出力するだけのコードです。
ヘッダにコードが記述されているので、モジュールも1つだけになっている単純な例です。
自分のコードがsub.hで、これを公開すると思ってください。

(B)ソースに書く場合は、テンプレートのインスタンス化が悩ましい

sub.hの実行コードをソースに移し、(静的)ライブラリにする形態がmain_lib.cpp、sub_lib.h、sub_lib.cppになります。

main_lib.cpp

#include <iostream>
#include "sub_lib.h"
int main() {
    Hoge hoge;
    hoge.print(std::cout);
    return 0;
}

sub_lib.h

#pragma once
struct Hoge {
    template<typename T> void print(T& out);
};

sub_lib.cpp

#include <ostream>
#include "sub_lib.h"
template<typename T>
void Hoge::print(T& out) {
    out << "ほげ" << std::endl;
}
template void Hoge::print(std::ostream&);

気づきましたでしょうか？

sub_lib.cppの最終行に、テンプレートのインスタンス化用の定義が入っています。この行はstd::coutのクラスであるstd::ostreamが定義されています。これがないと main_lib.cpp 側の hoge.print(std::cout) 呼び出しでundefined referenceが発生しちゃうわけです。呼び出す側のコードで、T=std::outputstreamなメソッドを必要とするので、呼び出される側のコードでそのインスタンス化が必要になるということです。

つまり呼び出す側のコードで使いたいTが増えるごとに、呼び出される側にこの行が必要になるということになります。これが面倒だというのが(B)です。

(C)ヘッダに書く場合は、同じものが複数展開されるため、それぞれでコードが異なりうる懸念がある

説明のため、元のコードを以下のようにしています。

• main.cpp→main_diff.cpp
• sub.h→sub_diff_v1.h

さらに同じものを複数展開するために、

• sub.h→sub_diff_v2.h
• sub2_diff.h
• sub2_diff.cpp

というのを用意しています。ようはモジュールを2つに増やし、それぞれにsub.h相当をインクルードして呼び出させるということです。
sub2側はライブラリにして、main側からリンクします。

main_diff.cpp

#include <iostream>
#include "sub_diff.h"
#include "sub2_diff.h"
int main() {
    Hoge hoge;
    hoge.print(std::cout);
    sub2();
    return 0;
}

sub_diff_v1.h

#pragma once
#include <ostream>
struct Hoge {
    template<typename T> void print(T& out) { out << "ほげ" << std::endl; }
};

sub_diff_v2.h

#pragma once
#include <ostream>
struct Hoge {
    template<typename T> void print(T& out) { out << "ふが" << std::endl; }
};

sub2_diff.h

#pragma once
void sub2();

sub2_diff.cpp

#include <iostream>
#include "sub_diff.h"
#include "sub2_diff.h"
void sub2() {
    Hoge hoge;
    hoge.print(std::cout);
}

各.cppファイルでインクルードしてるファイルがsub_diff.hになっていますが、これは_v1/_v2というサフィックスがついたファイルをmake注にコピーして作成しています。何を意図しているかというと、main_diff側と、libsub2.a側で異なるバージョンのsub_diff.hを使ったケースの再現です。そのままビルドすると、main_diff側のコードに一本化されて動きますが、最適化させるとインライン展開されてそれぞれ異なるコードで動作します。

最後に

C++を使ってる人なら誰もが一度はどうしようかと悩むところだと思いますが、あっちを立てればこっちが立たずみたいな状況なので、意見を集めてみてもいいかなと思って、書いてみました。参考までに私は公開ソースなら全部ヘッダにしていて、非公開なら規模次第でソースにしてます。テンプレートは限定的な使い方にします。

※勘違いの指摘なども歓迎です