ん～、前哨戦で終了するかもしれませんが、自分の勉強がてら。と、今使っているシステムにできれば組み入れたいので。
将来的に LINQ for C++ ができたとしても、VC++2010 に組み入れられるとは限らないので、やむなく自作ってところでしょうか。実験的なものでなので、拡張性/可読性を考えて導入するかどうかは決めましょう、ということで。

ラムダ式と std::function が使えるようになったから、じゃあ、LINQ らしいメソッドチェーンの方法を試してみたらと思ってざっと書いてみると。

GoingNative 9: LINQ for C/C++, Native Rx, Meet Aaron Lahman | C9::GoingNative | Channel 9
http://channel9.msdn.com/Shows/C9-GoingNative/GoingNative-9-LINQ-for-C-Native-Rx-RxC-Meet-Aaron-Lahman

ああ、確かに上記と同じ方法になります。

#include <string>
#include <iostream>
#include <vector>
#include <algorithm>
#include <functional>
#include <tuple>
using namespace std;

class Vector : public vector<int> {
protected:
	Vector *_v;
public:
	Vector() :
		_v(NULL) {
	}
	~Vector() {
		if ( _v != NULL ) {
			delete _v;
		}
	}
	Vector &From( vector<int> &vec ) {
		// アップキャストしてるが、今回はこれで ^^;
		return *(Vector*)&vec;
	}
	Vector &Where(function<bool(int n)> func) {
		// 毎回 new しているが、遅延実行させるため iterator を使う予定
		if ( _v != NULL ) delete _v;
		_v = new Vector;
		for_each( begin(), end(),
			[=](int n) { if(func(n)) _v->push_back(n); });
		return *_v;
	}
	Vector &Select(function<int(int n)> func) {
		if ( _v != NULL ) delete _v;
		_v = new Vector;
		for_each( begin(), end(),
			[=](int n) { _v->push_back(func(n)); });
		return *_v;
	}
};


int main( void )
{
	Vector vec;
	for ( int i=0; i<10; i++ ) {
		vec.push_back( i );
	}
	
	auto query =
		vec.Where([](int &n)->bool{ return n % 2 == 0 ; })
		.Select([](int &n)->int{ return n*10 ; });
		
	for_each( query.begin(), query.end(),
		[](int n) { cout << n << endl; });
}

肝心の「遅延評価」ができていないので、LINQ とは言えませんが、まあ、表面上はコンパイルが通るし、実行も正常。

D:\work\blog\src\alice>lamda001
0
20
40
60
80

_v = new Vector() してから return *_v で method chain を実現しているんですが、これ memory leak してないか？と思ったのですが、調べるとリークしてませんね。参照で返しているのでブロック外に出ると自動的に解放されています。

元々の vecotr ではなくて、Vector を使わないと駄目なのは、駄目駄目なのでこれはなんとかしないと。
あと遅延評価は C# の IEnumable 相当を作るよりも、iterator をそのまま使いたいんですよね。やっぱり STL と互換性を持たせたいから。

関数ポインタを無理矢理取得して、別の関数ポインタに入れる方法 | Moonmile Solutions Blog
http://www.moonmile.net/blog/archives/3580

なところで、関数ポインタを無理矢理 void * に入れて保存すれば ok ? と妄想していたのですが、いやいや、std::function を使えば lambda 式を保存できるよ、という話です。
要は、for_each や remove_if のような algorithm 系の関数に設定する関数をどうしたら class に押し込めるか？という問題だったので。

■実験用のソース

実験したコードはこんな感じです。

#include <string>
#include <iostream>
#include <vector>
#include <algorithm>
#include <functional>
using namespace std;

class Alice 
{
protected:
	vector<string> _lst;
public:
	Alice() {
		_lst.push_back("alice");
		_lst.push_back("luwis");
		_lst.push_back("lolita");
	}
	void disp1() {
		// lambda 式を直接扱う
		for_each( _lst.begin(), _lst.end(),
			[](string &s){ cout << "name: " << s << endl; });
	}
	void disp2() {
		// lambda 式を一度 auto 変数に入れる
		auto func = [](string &s){ cout << "name: " << s << endl; };
		for_each( _lst.begin(), _lst.end(), func );
	}
	
	// こんな風にクラスメソッドで扱うにはどうすればよいのか？
	void func(string s) {
		cout << "name: " << s << endl; 
	}
	void disp3() {
		// これはコンパイルエラー
		// for_each( _lst.begin(), _lst.end(), func );
		// これもコンパイルエラー
		// for_each( _lst.begin(), _lst.end(), mem_fun(&Alice::func));
		// 代替案として lambda でくるむ
		for_each( _lst.begin(), _lst.end(),
			[this](string s){ this->func(s); });
	}
	

	// std::function で定義	
	function<void(string)> func1 ;
	void disp4() {
		// コンストラクタ等で定義しておく
		this->func1 = [](string s){ cout << "name: " << s << endl; };
		// クラスの内部関数風に呼び出す
		for_each( _lst.begin(), _lst.end(), func1 );
	}
};

int main( void )
{
	Alice alice;
	
	alice.disp1();
	alice.disp2();
	alice.disp3();
	alice.disp4();
	
	return 0;
}

Alice::disp3 のように、Alice::func を表示用の関数として for_each から呼び出したいわけです。
普通に lambda 式を使うのが良いのですが、それを Alice クラスの内部関数として定義しておきたいわけです。これは、lambda 式の中身が複雑化したり複数の場所で使われるときに、一括管理しておきたいという想定です。lambda 式自体は auto 変数に代入しておくと、そのメソッド内では利用できるのですが、他では再利用できないので、クラス内のメンバ関数としようとしている訳です。

で、通常のメンバ関数の場合は &Alice::func のように取れるのですが、for_each に渡さないいけないのはグローバル関数か、要素のメソッドのなのです。この場合、vector としているので、要素の型である string に関数を仕込むのは無理があります。avoid な方法としては、string を一旦くるむ方法もありますが、かなり冗長です。

そこで出た代案としては、

		// 代替案として lambda でくるむ
		for_each( _lst.begin(), _lst.end(),
			[this](string s){ this->func(s); });

な方法です。非常にダサいですが、一度 lambda 式でくるんでメンバ関数を呼び出します。まあ、ダサいですが実用には耐えられますね。

じゃあ、ひょっとすると関数ポインタをなんらかの形で void * として保存しておいて、利用する時にもう一度元の関数型に直してやれば、動くのではないか？と思ったのが、「関数ポインタを無理矢理取得して～」の方法なのですが、いやいや、そこまでやる必要はなかったということです。

	// std::function で定義	
	function<void(string)> func1 ;
	void disp4() {
		// コンストラクタ等で定義しておく
		this->func1 = [](string s){ cout << "name: " << s << endl; };
		// クラスの内部関数風に呼び出す
		for_each( _lst.begin(), _lst.end(), func1 );
	}

std::function 型としてメンバ変数を定義しておき、その変数に lambda 式を代入しておきます。本来は、ここを本当のメンバ関数にしたいところですが、贅沢は言いません（苦笑）。これで実用に耐えられるので。
コンストラクタかなんらかの initialize 関数を作っておいて、lambda 式を変数に入れます。つまり、これは変数なので、型さえあっていれば、lambda 式を入れ替えることが可能なんですね。こうなると「for_each( _lst.begin(), _lst.end(), func1 );」の部分はまったく変えずに、func1 の中身だけすりかえしてまえば表示が変わるという仕組みができあがります。

これで、ひとまず目的は達成ということで。

c++ で lambda 式を使うと for_each を使うのが楽になる…のですが、一応、以前の書き方をメモ。

#include <string>
#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;

static void f1( string s ) {
	cout << s << endl;
}

int main( void )
{
	vector<string> lines;
	lines.push_back("masuda");
	lines.push_back("tomoaki");
	lines.push_back("alice");

	// 普通にforを使う
	for( auto it=lines.begin(); it!=lines.end(); ++it ) {
		cout << (*it) << endl;
	}

	// for_each と lambda を使う
	for_each( lines.begin(), lines.end(),
		[](string s){ cout << s << endl; });

	// for_each と static 関数を使う
	for_each( lines.begin(), lines.end(), f1 );

	// for_each と auto 関数を使う
	auto f2 = [](string s){ cout << s << endl; };
	for_each( lines.begin(), lines.end(), f2 );

	return 0;
}

ノーマルに for 文を使って書くと一時変数が必要になる。auto が無かった時代には「vector::iterator it = lines.begin()」と書かないと駄目だったのですが、このあたりは auto を使えば十分。この長い書き方が嫌で typedef したりするのですが、今は不要です。

	// 普通にforを使う
	for( auto it=lines.begin(); it!=lines.end(); ++it ) {
		cout << (*it) << endl;
	}

for_each と lambda 式を使うとこんな感じ。iterator がそのままラムダ式の引数に入るのでそれを使えばOKです。
このあたりが LINQ っぽく書けるってことなのですが、このままではほど遠いかなと。まあ、慣れかもしれませんが、イテレーターを lambda 式の引数として受けないといけないのがいまいちです。

	// for_each と lambda を使う
	for_each( lines.begin(), lines.end(),
		[](string s){ cout << s << endl; });

lambda 式を auto で受けて関数ポインタとして使う方法です。lambda 式部分が長い場合や、動的に切り替えたい場合に使える…と思うのですがよくわからず。
本来は、この auto を関数の外側に出したいのですが、それを真面目に出すと…

	// for_each と auto 関数を使う
	auto f2 = [](string s){ cout << s << endl; };
	for_each( lines.begin(), lines.end(), f2 );

下記のように、処理関数を外側に出します。これだと普通ですね。というか、これが最初の for_each の使い方です。

static void f1( string s ) {
	cout << s << endl;
}

...
	// for_each と static 関数を使う
	for_each( lines.begin(), lines.end(), f1 );

■クラス内で for_each を使う

先の例では、main 関数内で使っていたのですが、今度はクラスのメソッド内で使ってみます。
使い方は、まあ、main 関数と一緒です。内部的に vector でコレクションを持っていて disp_for メソッドなり、一括で表示させる関数を想定しています。

class Alice
{
public:
	vector<string> lines;

	Alice() {
		lines.push_back("masuda");
		lines.push_back("tomoaki");
		lines.push_back("alice");
	}

	void disp_for()
	{
		// 普通のfor文
		for( auto it=lines.begin(); it!=lines.end(); ++it ) {
			cout << (*it) << endl;
		}
	}
	void disp_for_lambda() {
		// lambda 式を使う
		for_each( lines.begin(), lines.end(),
			[](string s){ cout << s << endl; });
	}
	void disp_for_auto() {
		// auto に代入して使う1
		auto f2 = [](string s){ cout << s << endl; };
		for_each( lines.begin(), lines.end(), f2 );
	}

	void f1(string s)
	{
		cout << s << endl;
	}
	void disp_for_inner_func()
	{
		// 出来そうで、できない？？？
		// for_each( lines.begin(), lines.end(), &Alice::f1 );
		// 素直に lambda 式から呼び出す
		for_each( lines.begin(), lines.end(),
			[this](string s){ this->f1(s); });
	}
};

main 関数とちょっと違うのは、以下の disp_for_inner_func メソッドのところです。
書き方としては、for_each で Alice クラスの内部関数 f1 を使いたいところなのですが…これは出来ません。
関数ポインタ「&Alice::f1」を使って、lambda 式のようにイテレーターを引数にして、と思って使ってみると、どうやってもコンパイルが通りません。

	void f1(string s)
	{
		cout << s << endl;
	}
	void disp_for_inner_func()
	{
		// 出来そうで、できない？？？
		for_each( lines.begin(), lines.end(), &Alice::f1 );
		// 素直に lambda 式から呼び出す
		for_each( lines.begin(), lines.end(),
			[this](string s){ this->f1(s); });
	}

VC++ でコンパイルと以下のようなエラーになります。

C:\Program Files\Microsoft Visual Studio 10.0\VC\INCLUDE\algorithm(22) : error C
2064: 1 引数を取り込む関数には評価されません。
        C:\Program Files\Microsoft Visual Studio 10.0\VC\INCLUDE\algorithm(32) :
 コンパイルされたクラスの テンプレート のインスタンス化 '_Fn1 std::_For_each<std
::basic_string<_Elem,_Traits,_Ax>*,_Fn1>(_InIt,_InIt,_Fn1)' の参照を確認してくだ
さい
        with
        [
            _Fn1=void (__thiscall Alice::* )(std::string),
            _Elem=char,
            _Traits=std::char_traits<char>,
            _Ax=std::allocator<char>,
            _InIt=std::basic_string<char,std::char_traits<char>,std::allocator<c
har>> *
        ]
        alice029.cpp(66) : コンパイルされたクラスの テンプレート のインスタンス
化 '_Fn1 std::for_each<std::_Vector_iterator<_Myvec>,void(__thiscall Alice::* )(
std::string)>(_InIt,_InIt,_Fn1)' の参照を確認してください
        with
        [
            _Fn1=void (__thiscall Alice::* )(std::string),
            _Myvec=std::_Vector_val<std::string,std::allocator<std::string>>,
            _InIt=std::_Vector_iterator<std::_Vector_val<std::string,std::alloca
tor<std::string>>>
        ]

実は、これは for_each の使い方が間違っているので、コンパイルエラーになるのです。

■メンバ関数は mem_func を使う。ただし要素のメンバ関数に限る

for_each で設定するループ関数は、実は「要素」に対するメソッドになります。lambda 式を使うと分かりづらいのですが、先の for_each では、vector の string に対して関数が適用される、という意味になります。
なので、メンバ関数を for_each に指定する場合は、そのメンバ関数を持つ要素クラスをつくらないと駄目なわけですよ。なるほど。

class Point {
public:
	int x, y, z;
public:
	Point(int x, int y, int z ) {
		this->x = x;
		this->y = y;
		this->z = z;
	}
	void disp() {
		cout << x << "," << y << "," << z << endl;
	}
};

int main( void )
{
	// mem_fun はこう使う
	vector<Point*> ps;
	ps.push_back( new Point(1,1,1));
	ps.push_back( new Point(2,2,2));
	ps.push_back( new Point(3,3,3));
	for_each( ps.begin(), ps.end(), mem_fun(&Point::disp));
}

こんな風に、Point クラスを作っておいて、disp メソッドがあるという場合を想定します。
vector コレクションに対して、for_each を適用すると、この disp メソッドを適用する、ということになるのです。
で、メソッド関数の場合にはそのまま適用できないので、上記のように mem_fun という補助関数を使います。内部的には、vecotr::iterator に対して disp メソッドを呼び出すという、関数ポインタを使うという作りになっています。

確かに、for_each だけでなく、remove_if や find_if のような比較関数を設定する場合、要素に対して comp 関数がある訳で、納得できる仕様ですよね。

ちなみに、find_if に比較関数 comp を追加して表示させるとこんな風になる。

class Point {
public:
	int x, y, z;
public:
	Point(int x, int y, int z ) {
		this->x = x;
		this->y = y;
		this->z = z;
	}
	void disp() {
		cout << x << "," << y << "," << z << endl;
	}
	bool comp( Point *pt ) {
		if ( this->x == pt->x &&
		     this->y == pt->y &&
		     this->z == pt->z ) {
			return true;
		} else {
			return false;
		}
	}
};

int main( void )
{
	Point *p1 = new Point(2,2,2);
	auto it = find_if( ps.begin(), ps.end(),
		bind2nd(mem_fun(&Point::comp),p1));
	if ( it != ps.end() ) {
		cout << "found." << endl;
	} else {
		cout << "no found." << endl;
	}
	return 0;
}

比較する Point ポインタを渡すために、bind2nd 関数を使うところが「アレ」ですが、まぁ、できます。
うーん、C++ template パズルを作りたい場合はこれでもいいのですが、実運用として（特に可読性としては）はこれはいまいちかなぁと常々思っています。

この comp という比較関数ですが、Point クラスに属さないと駄目なところが欠点ですよね。vector の場合はよいのですが、さて、vectorとか、vectorの場合はどうすれば良いのか？ってことです。比較関数として equal_to() とか使えばいいんですかね？

	auto b = find_if( lines.begin(), lines.end(),
		bind2nd( equal_to<string>(), "tomoaki" ));
	if ( b != lines.end() ) {
		cout << "found." << endl;
	} else {
		cout << "no found." << endl;
	}

まあ、慣れるとそれでもいいのですが、lambda 式があったり LINQ があったりする時代なので、ちょっとパズルは嫌だなぁと。
今だったら、下記のように lambda 式を使います。

	// lambda を使う
	auto b2 = find_if( lines.begin(), lines.end(),
		[](string s)->bool{ return s == "tomoaki"; });
	if ( b2 != lines.end() ) {
		cout << "found." << endl;
	} else {
		cout << "no found." << endl;
	}

このほうが可読性が高いです、と私は思います。

■プリミティブなクラスに比較関数をつけるのか？

で、話を戻すと、

	void disp_for_inner_func()
	{
		// 出来そうで、できない？？？
		// for_each( lines.begin(), lines.end(), &Alice::f1 );
		// 素直に lambda 式から呼び出す
		for_each( lines.begin(), lines.end(),
			[this](string s){ this->f1(s); });
	}

のところで、内部関数を渡せるほうが読み方としては私にはなんとなく自然な訳です。remove_if や find_if には equal_to のような関数が用意されていますが、カスタム表示のような disp 関数の場合は無理ですよね。
逃れる方法としては、ラムダ式からメンバ関数を呼び出すので、これで十分用途は足りるのですがなんかダサい。。。

class Point {
public:
	int x, y, z;
public:
	Point(int x, int y, int z ) {
		this->x = x;
		this->y = y;
		this->z = z;
	}
	void disp() {
		cout << x << "," << y << "," << z << endl;
	}
	bool comp( Point *pt ) {
		if ( this->x == pt->x &&
		     this->y == pt->y &&
		     this->z == pt->z ) {
			return true;
		} else {
			return false;
		}
	}
};

あと、発想として Point クラスに比較関数などなどが付け加わるのもいまいちなのです。Point クラスはデータクラスとして必要最低限にとどめておきたいし、のちのちに拡張させないようにしたい。C++ 的には include 先が変更されるのは避けたいわけで、そうなると「将来追加されるかもしれない」comp 関数などを追加しておくのは「到底無理」な訳です。
そうなると、comp 関数のほうも使うときに適宜用意するのが適当で、

Alice {
	vector<Point*> ps;
public:
	bool comp( Point *p1, Point *p2 ) {
		if ( p1->x == p2->x &&
             p1->x == p2->y &&
             p1->x == p2->z ) {
			return true;
		} else {
			return false;
		}
	}
	bool find( Point *p ) {
		return for_each( ps.begin(), ps.end(),
			&Alice::comp, p );
	}
};

な風に、2つの引数を持つ comp メソッドを for_each から直接呼び出せたらよいなぁ、と。comp メソッドの中身はここでは x,y,z の全てを比較していますが、workarea などを含めると独自に comp を作ったほうが良い場合が多いのです。高速化のために内部的には id を比較するだけとか。

あとは、LINQ 風に

bool find( Point *p ) {
	return ps.from( it ).where(it == *p );
}

あるいは

bool find( Point *p ) {
	auto result = ps.from(it).where(it==*p);
	return result != ps.end();
}

としてしまうとか。まあ、こっちのは話はまた別の機会に。

ObservableCollection(T) クラス (System.Collections.ObjectModel)
http://msdn.microsoft.com/ja-jp/library/ms668604.aspx
Skeleton of GOF’s Design Pattern
http://www002.upp.so-net.ne.jp/ys_oota/mdp/Observer/index.htm

2つのViewの変更が、同時に行われるときのModelの挙動を考察 | Moonmile Solutions Blog
http://www.moonmile.net/blog/archives/3575

で、__event/__hook で実装しようと思っていたのですが、基本に帰って Observer パターンを調べてみると、ああ、これでいいじゃんということにしました。車輪の再発明ってやつです。

• View と Data/Model を独立させよう
• Model の変更を複数の View に伝える

という点も従来の Observer パターンで ok です。
このあたり、notify で渡す時に、notify( Model * ) のように Model の型を渡してしまうと Model の型に縛られる（当たり前）ってことになるのですが、ここは object 型/void *で十分な訳です。受ける側で、(Model*)object としてキャストをすれば良いわけで…なるほど。

複数の view への通知に対しては、addObjserver/revemoOPbserverを実装して通知先の Observable をコレクションしておきます。元々の Observer パターンがこうなので、私の見落としですね。

で、GridView と データコレクションとの連携、いわゆるコレクションのデータバインドに関しては、ObservableCollection が良く使われるので、これを C++ で実装してみます。

// Doc-View に直す暫定 Observable パターン
#include <string>
#include <iostream>
#include <list>
#include <algorithm>

using namespace std;

class IObserver {
public:
	// Action
	enum Action {
		Add,
		Remove,
		Replace,
		Move,
		Reset,
	};
	virtual void CollectionChanged( void *ob, Action mode ) {}
	virtual void PropertyChanged( void *ob, const char *propName ) {}
};

class IObservable {
protected:
	std::list<IObserver*> _lst;
public:
	void addObserver( IObserver *ob ) {
		_lst.push_back( ob );
	}
	void removeObserver( IObserver *ob ) {
		_lst.remove( ob );
	}
	void notify( const char *propName ) {
		for ( auto it = _lst.begin(); it != _lst.end(); ++it ) {
			(*it)->PropertyChanged( this, propName );
		}
	}
};

template <class T> class ObservableCollection : public std::list<T> {
protected:
	std::list<IObserver*> _lst;
public:
	void addObserver( IObserver *ob ) {
		_lst.push_back( ob );
	}
	void removeObserver( IObserver *ob ) {
		_lst.remove( ob );
	}
	void notify( T item, IObserver::Action mode ) {
		for ( auto it = _lst.begin(); it != _lst.end(); ++it ) {
			(*it)->CollectionChanged( item, mode );
		}
	}
public:
	// override
	void push_back( T item ) {
		std::list<T>::push_back( item );
		notify( item, IObserver::Add );
	}
	void remove( T item ) {
		std::list<T>::remove( item );
		notify( item, IObserver::Remove );
	}
	void removeAt( int index ) {
		for ( auto it=begin(); it!=end(); ++it ) {
			if ( index-- == 0 ) {
				remove( *it );
			}
		}
	}
	void insert( std::list<T>::iterator it, T item ) {
		std::list<T>::insert( it, item );
		notify( item, IObserver::Add );
	}
		
	void insertAt( int index, T item ) {
		for ( auto it=begin(); it!=end(); ++it ) {
			if ( index-- == 0 ) {
				insert( it, item );
			}
		}
	}
	void clear() {
		std::list<T>::clear();
		notify( item, IObserver::Reset );
	}
};

#define PROPERTY( _t, _m ) \
public:	_t m_##_m;	\
public:				\
	__declspec(property(get=get##_m,put=set##_m)) _t _m;	\
	_t get##_m() { return m_##_m; }	\
	void set##_m( _t v ) {			\
		if ( m_##_m != v ) {		\
			m_##_m = v;				\
			notify( #_m );			\
		}							\
	}

class Data : public IObservable {
public:
	PROPERTY( string, Name );
	PROPERTY( int, Age );
public:
	Data( string name, int age ) {
		this->m_Name = name;
		this->m_Age = age;
	}
};
class View : public IObserver
{
public:	
	virtual void CollectionChanged( void *sender, IObserver::Action mode ) 
	{
		Data *data = (Data*)sender;
		cout << "name: " << data->Name << " " << mode  << endl;
	}
	virtual void PropertyChanged( void *sender, const char *propName ) 
	{
		Data *data = (Data*)sender;
		cout << "name: " << data->Name << " " << propName  << endl;
	}
};

int main( void )
{
	ObservableCollection<Data*> lst;
	
	lst.push_back( new Data( "masuda", 20 ));
	lst.push_back( new Data( "tomoaki", 30 ));
	lst.push_back( new Data( "alice", 10 ));
	
	View view;
	// append handler
	lst.addObserver( &view );
	for_each( lst.begin(), lst.end(), 
		[&view](Data *v){ v->addObserver( &view );});
	
	Data *d = new Data( "nanashi", 20 );
	d->addObserver( &view );
	// append item
	lst.push_back(d);
	// change property
	d->Name = "NANASHI";
	
	return 0;
}

C#/VB の ObservableCollection と合わせるために、CollectionChanged と PropertyChanged というイベントが発生します。通知元の Model/Data では IObservable を継承して、通知先の View では IObserver を継承します。__event/__hook を使うと、直接メンバ関数にマッピングができるので継承自体がいらないのですが、名称の統一性を考えると明示的に継承したほうがよさそうです。

Collection にした場合、それぞれの要素の IObserver のコレクション _lst が無駄に思えるので、もう少し改修は必要でしょうねぇ。まぁ、昨今のメモリ事情ならばこのままでも良いかと。

IObserver/IObservable というインターフェースのような名前にしていますが、実装が入っています。純粋関数にしても良いのですが、継承するけど通知されたくない（？）という中途半端な状態でも ok なので、これでよいかと。