複数クラスからアクセスする共通クラスを実装したい

Question

##環境
環境は、以下の通りです。
言語：c++
環境：VisualStudio2019

##前提
以下のように、ClassAの中に、
テキストファイルをopenし、文字を書き込んで、closeするTxtWriterクラスがあるとします。

class ClassA{
public:
	//! コンストラクタ
	//! m_pTxtWriterを実体化し、テキストファイルをopenする
	ClassA();
	//! デストラクタ
	//! テキストファイルをcloseする
	~ClassA();

	//! 処理
	//! この関数の中でm_pTxtWriterを用いてテキストに書き込む
	void Process(const short* input, short* output);

private:
	//! テキスト書き込みクラス
	TxtWriter* m_pTxtWriter;
};


/**********************************************/
//! TxtWriterクラス
/**********************************************/
//! コンストラクタ
TxtWriter::TxtWriter(std::string fname, std::string type, char delimiter) : m_sType(type), m_cDelimiter(delimiter)
{
    // 開かなかったらエラーで終了
    if(fopen_s(&m_fp, fname.c_str(), "w") != 0)
    {
        printf("Error! %s can not be opened", fname.c_str());
        exit(1);
    }
}

//! デストラクタ
TxtWriter::~TxtWriter()
{
    fclose(m_fp);
}

//! データを1行書き込み
template <typename T>
void TxtWriter::WriteLine(const T* data, const int data_num)
{
    std::string type = m_sType+"%c";
    for(int i=0; i<data_num-1; i++)
    {
        fprintf_s(m_fp, type.c_str(), data[i], m_cDelimiter);
    }
    fprintf_s(m_fp, type.c_str(), data[data_num-1], '\n');
}

##やりたいこと
インスタンス化された複数のclassAで、m_pTxtWriterを共通で使用したい。

##質問
m_pTxtWriterをコンストラクタで実体化すると、それぞれのclassAで実体を持つことになるので、上記の実装は良くないということは分かるのですが、どのように実装したら良いのか分かりません。

良い実装方法を教えていただけないでしょうか。

##補足
皆さま、ご回答をありがとうございます。説明不足な点がありましたので、補足させていただきます。

classAの仕様として、
・TxtWriterクラスはclassAの所有物である。
・classAを使う人は、classAのProcess関数を呼んだらテキストに出力されることを期待している
（classAを使う人にTxtWriterクラスを準備させたくない）
・複数のclassAインスタンスの出力先は固定
という観点から、外部から与えるのではなく、

ClassAのstaticなメンバ変数としてTxtWriterの実体または参照先（単純ポインタやstd::shared_ptr<TxtWriter>等）を保持する。

という方法が良いかなと考えました。
もし上記の方法で実装する場合、
・TxtWriterクラスは、どのようにしてインスタンス化するのでしょうか？
・注意する点（排他制御が必要）などありましたら、教えていただけないでしょうか。

質問ばかりで申し訳ありませんが、よろしくお願いいたします。

Answer 1

いろんなやり方あるやろけど、僕ならTxtWriterを外から与える。

//! この関数の中で(引数に与えた)writerを用いてテキストに書き込む
void Process(const short* input, short* output, **TxtWriter* writer**);

あるいは void setWriter(TxtWriter writer) { m_pTxtWriter = writer; }* を追加。
※ ClassAのコンストラクタ引数に加えてもいい

[追記] ClassAにしてみればTxtWriterは処理のための道具であり、
そいつが唯一ひとつか/共有されてるかなんてどーでもいいこと。
だから std::shared_ptr<TxtWriter> をメンバに持つのは(個人的には)好まない。

※ 「TxtWriterはClassAの所有物だ」と考えるならその限りではないけどねー
要は設計者の意図次第かと。

Comments

[fana]

> void setWriter(TxtWriter* writer) { m_pTxtWriter = writer; }

とは，「writerの指す先へのアクセスの正当性（寿命管理）については，これを与える側で然るべく担保せよ」という話であり，
（このことはいちいち注釈なりに書かずとも引数の型（とメソッドの名前）で十分に表明できている）

で，そのことの具体的な手段として shared_ptr なりを用いる実装がしたいならばそれは ClassA の外側で好きにやればいい

…と読みましたが妥当でしょうか？　師匠！

[episteme]

御意。
「writerの生死についてはClassAの責任範囲ではない」って立場なら、
TxtWriter*(or TxtWriter&)を引き渡して"コレ使って処理しろ"って言えばいい。

[fana]

ご教示いただきまするは　ありがたきしあわせに存じまする

Answer 2

基本的な方策としては、以下を思いつきます。
0. ClassAのコンストラクタで、利用するTxtWriterを受け取る。TxtWriterのインスタンスが共通かどうかはClassAの利用側でコントロールする。
0. ClassAのstaticなメンバ変数としてTxtWriterの実体または参照先（単純ポインタやstd::shared_ptr<TxtWriter>等）を保持する。

質問の内容だとよくわからない点として、ClassAが共用で利用するTxtWriterは、ファイルパスが固定だったりするんですかね？ってことですね。設定によってファイルパスが変わるとか、プロセスの動作中に途中でファイルを切り替えるとか、プロセスの動作中にファイルのオープン/クローズが必要になるとか、そういった要件次第で最適な設計はだいぶ変わると思います。

Answer 3

TxtWriterの出力先が固定であるなら、シングルトンにすればよいのではないかと。
シングルトンのベターな実装方法

---

[補足の点について]

・TxtWriterクラスは、どのようにしてインスタンス化するのでしょうか？

シングルトンクラスにはインスタンス取得用のゲッターを用意します。
（リンク先の記事だとget_instance() がそれ）

・注意する点（排他制御が必要）などありましたら、教えていただけないでしょうか。

fwriteはスレッドセーフなので、fprintf_sも多分スレッドセーフだと思いますが、複数回に分けて呼び出してるなら、マルチスレッド環境下だと

1. スレッド1のfprintf_s処理
2. スレッド1のfprintf_s処理
3. スレッド2のfprintf_s処理
4. スレッド1のfprintf_s処理

という事が起こり得るので、WriteLineの呼出順で出力順序を保証したいなら、WriteLineの開始終了で同期オブジェクト（クリティカルセクションやmutex）で保護してやる必要があるでしょう。シングルスレッドでやるなら、別に気にしなくていいです。
Win32APIでスレッド間の排他制御(クリティカルセクション)を行う

最近のC++には疎いけど、もう標準ライブラリで用意されていたりするのかな？
C++11における同期処理(std::mutex, std::unique_guard, std::lock_guard, std::condition_variable)

Answer 4

補足

に対して．

・TxtWriterクラスは、どのようにしてインスタンス化するのでしょうか？

ClassAのインスタンス生成時に，TxtWriterが無ければ作り，
ClassAのインスタンス破棄時に，自身が最後のインスタンスであればTxtWriterを捨てる

とかで良いのでは．

//雰囲気コード
class ClassA
{
public:
	ClassA()  //（※他のコンストラクタがあるなら忘れずに同じことをするように）
	{
		if( !ms_pTW ){	ms_pTW = new TxtWriter();	}
		++ms_nInstance;
	}

	~ClassA()
	{
		if( --ms_nInstance == 0 )
		{//自身が最後のインスタンスだったなら捨てる
			delete ms_pTW;
			ms_pTW = nullptr;
		}
	}

private:
	class TxtWriter{ /*(略)*/ };

	static TxtWriter *ms_pTW;
	static size_t ms_nInstance;
};

ClassA::TxtWriter *ClassA::ms_pTW = nullptr;
size_t ClassA::ms_nInstance = 0;

---

[追記]
スマートポインタで強引に．
うーん…

class ClassA
{
private:
	class TxtWriter{ /*(略)*/ };

public:
	//ClassA のインスタンス生成手段
	static ClassA Create()
	{
		auto spTW = ms_wpTW.lock();
		if( !spTW )
		{
			spTW = std::make_shared<TxtWriter>();
			ms_wpTW = spTW;
		}
		return ClassA( spTW );
	}

private:
	//private ctor
	ClassA( std::shared_ptr< TxtWriter > spTW ) : m_spTW(spTW) {}
	//data
	std::shared_ptr< TxtWriter > m_spTW;
	//static
	static std::weak_ptr<TxtWriter> ms_wpTW;
};

std::weak_ptr<ClassA::TxtWriter> ClassA::ms_wpTW;

Comments

[episteme]

TxtWriterがClassAの所有物であり、全インスタンスがひとつのTxtWriterを共有したいなら、
class変数(=static変数)となるでしょねー