C# と VB.NET の質問掲示板

びーしむです。

あるクラス Data がありまして、データは派生クラスで定義しようと思いました。
これらの派生クラスは vector や list などを使ってデータを保持しています。
派生クラスのポインタを受け取れればデータにアクセスできるのですが、
親の Data クラスのポインタしか受け取れないとき、これらのデータにアクセスする方法はないでしょうか？

std::vector<int>::iterator itV;
std::list<int>::iterator   itL;
hoge<int>::iterator it1 = itV;
hoge<int>::iterator it2 = itL;
こんなことができれば、親のクラスに 
virtual hoge<int>::iterator begin()
virtual hoge<int>::iterator end()
を定義できるのに思ったのですが。。。

よろしくお願いします。

以下、ソース
#include <numeric>
#include <vector>
#include <list>

class Data {};

class DataVector : public Data {
public:
	std::vector<int> m_Data;
}

class DataList : public Data {
public:
	std::list<int> m_Data;
}

main()
{
	DataVector 	data1;
	DataList	data2;
	int sum1 = std::accumulate(data1.m_Data.begin(), data1.m_Data.end(), 0);
	int sum2 = std::accumulate(data2.m_Data.begin(), data2.m_Data.end(), 0);

	Data *p1 = &data1;
	Data *p2 = &data2;
	int sum3 = std::accumulate(p1->begin(), p1->end(), 0);	//これを実現する方法はあるかな？
	int sum4 = std::accumulate(p2->begin(), p2->end(), 0);	//これを実現する方法はあるかな？
}

> 親の Data クラスのポインタしか受け取れないとき、これらのデータにアクセスする方法はないでしょうか？

たとえできたとしても
 
> int sum3 = std::accumulate(p1->begin(), p1->end(), 0);	//これを実現する方法はあるかな？
> int sum4 = std::accumulate(p2->begin(), p2->end(), 0);	//これを実現する方法はあるかな？

戻り値の型が int であることをどうやって知る?
std::vector<std::string> m_Data;
std::list<double> m_Data;
かもしんないよね?

型はint確定だってんなら、↓こんなお茶の濁しかたなら。

#include <numeric>
#include <vector>
#include <list>

class Data {
public:
  virtual int accumulate() const =0;
};

class DataVector : public Data {
public:
	std::vector<int> m_Data;
   virtual int accumulate() const { return std::accumulate(m_Data.begin(), m_Data.end(), 0); }
}

class DataList : public Data {
public:
	std::list<int> m_Data;
   virtual int accumulate() const { return std::accumulate(m_Data.begin(), m_Data.end(), 0); }
}

main()
{
	DataVector 	data1;
	DataList	data2;

	Data *p1 = &data1;
	Data *p2 = &data2;
	int sum3 = p1->accumulate();
	int sum4 = p2->accumulate();
}

επιστημη さん返信ありがとうございます。

> 戻り値の型が int であることをどうやって知る?
> 型はint確定だってんなら
データの持ち方が違うだけで、型については固定です。


>こんなお茶の濁しかたなら。
accumulate のような処理を複数個用意したいとき（またはメンバ関数にしたくないときなど）は、
ヘルパ関数を用意して

int AccumulateHelper(Data *p)
{
	DataVector *pV = dynamic_cast<DataVector*>(p);
	if(pV){return std::accumulate(pV->m_Data.begin(), pV->m_Data.end(), 0);}

	DataList *pL = dynamic_cast<DataList*>(p);
	if(pL){return std::accumulate(pL->m_Data.begin(), pL->m_Data.end(), 0);}

	return 0;
}

int AverageHelper(Data *p)
{
	DataVector *pV = dynamic_cast<DataVector*>(p);
	if(pV){return AverageImpl(pV->m_Data.begin(), pV->m_Data.end());}

	DataList *pL = dynamic_cast<DataList*>(p);
	if(pL){return AverageImpl(pL->m_Data.begin(), pL->m_Data.end());}

	return 0;
}

とやればできそうです。
処理の実装は、template を使えば良いのかな。

> class Data は、その派生クラスにてコレクションを持つことを知っているべきか否か
class Data はデータを保持するのが目的で、そのデータをどう使うかは Data の利用者に任せたい。
データを数式で表せるとき vector や list に展開して保持しなくていいからメモリが節約できると考えた。
例として accumulate や avarage を挙げましたが、他のどのような関数が必要になるかはわからない。

>Dataの利用者はDataの腹ん中を知らんでも使えるのがベストちゃうんか? 
class Data が iterator(派生クラスのイテレータをラッパーするようなクラスでもよい) の
begin, end を返せればできるなと思ったのですがその手法が良くないみたいですね。

他に考えた方法は、
１．処理時間を考えないで、std::vector<int> のコピーでデータを取得する関数を用意する
class Data {
public:
    virtual const std::vector<int> Get()const=0;
};

２．データは class Data が保持し、派生クラスは Update 関数を実装して m_Data を更新する。
class Data {
public:
    const std::vector<int>& Get()const{return m_Data;}
    virtual void Update(){}

protected:
    std::vector<int> m_Data;
};


なかなか難しいですね。。。

επιστημη さん、774RRさん、回答ありがとうございます。

> Data< std::vector<int> > user_data;
> みたいに使っちゃいかんのかしら?
こうですか？
template<typename Container>
class Data {
public:
    Container m_Data;
};

template<typename T>
int AccumulateHelper(Data<T> *p)
{
    return std::accumulate(p->m_Data.begin(), p->m_Data.end(), 0);
}

main()
{
    Data<std::vector<int> > data1;
    Data<std::list<int> >   data2;
    int sum1 = AccumulateHelper(&data1);
    int sum2 = AccumulateHelper(&data2);
}


>不明な持ち方しているデータを、データの持ち方知らないルーチンで演算したい
>ってのは無理な話。
ここを解決するために std::list のような begin(), end() と取得したイテレータ？に ++, -- がある
class Data が定義できればと考えました。
自分の例の場合はデータの型に汎用性は必要ないので
下記のインターフェースをもつ class Data のポインタを受け渡しすればと思ったのですが。
この考え方が間違ってるのかなぁ・・・

class Data {
public:
   class const_iterator {
       int operator * ()const;
       int operator ++ ();
       int operator -- ();
       ...
   };

    virtual const_iterator begin()const;
    virtual const_iterator end()const;
};


template + 特殊化ついては理解できていないので勉強しておきます。

メンバ関数まるっと横流しして↓こんなんでもいんじゃねぇかと。

#include <vector>
#include <list>
#include <iostream>
#include <numeric>

template<typename Container>
class Data {
    Container m_Data;
public:
  typedef typename Container::iterator iterator;
  typedef typename Container::const_iterator const_iterator;
  typedef typename Container::value_type value_type;
  iterator begin() { return m_Data.begin(); }
  const_iterator begin() const { return m_Data.begin(); }
  iterator end() { return m_Data.end(); }
  const_iterator end() const { return m_Data.end(); }
  void push_back(const value_type& x) { m_Data.push_back(x); }
};

int main() {
    Data<std::vector<int> > data;
//  Data<std::list<int> > data;
    data.push_back(1);
    data.push_back(2);
    data.push_back(3);
    
    int sum = std::accumulate(data.begin(), data.end(), 0);
    std::cout << sum << std::endl;
}

> Data<std::vector<int>>と Data<std::list<int>>のポインタを
> vector< Data??? * > 等で管理したい場合でした。

↓こんな雰囲気かのぉ...

#include <iostream>

#include <vector>
#include <list>
#include <iostream>
#include <numeric>
#include <algorithm>

template<typename T>
class AbstractData {
public:
  virtual int size() const = 0;
  virtual T* copy_to(T* out) const =0;
};

template<typename T,  template <typename U, class A=std::allocator<U> > class Container>
class Data : public AbstractData<T> {
  typedef typename Container<T> container;
  container data_;
public:
  typedef typename container::iterator iterator;
  typedef typename container::const_iterator const_iterator;
  typedef typename container::value_type value_type;
  iterator begin() { return data_.begin(); }
  const_iterator begin() const { return data_.begin(); }
  iterator end() { return data_.end(); }
  const_iterator end() const { return data_.end(); }
  void push_back(const value_type& x) { data_.push_back(x); }
  
  virtual int size() const { return data_.size(); }
  virtual T* copy_to(T* out) const { return std::copy(begin(), end(), out); }
};

int main() {
    std::vector<AbstractData<int>*> vad;
    
    Data<int,std::vector> vdata;
    vdata.push_back(1);
    vdata.push_back(2);
    vdata.push_back(3);
    vad.push_back(&vdata);

    Data<int,std::list>   ldata;
    ldata.push_back(4);
    ldata.push_back(5);
    ldata.push_back(6);
    ldata.push_back(7);
    vad.push_back(&ldata);
    
    for ( int i = 0; i < vad.size(); ++i ) {
      AbstractData<int>* pdata = vad.at(i);
      int n = pdata->size();
      int* first = new int[n];
      int* last = pdata->copy_to(first);
      int sum = std::accumulate(first, last, 0);
      std::cout << "sum-" << i << '\t' << sum << std::endl;
      delete[] first;
    }
}