40

C および C++ のガベージ コレクターである libgc を使用しています。STL コンテナをガベージ コレクション可能にするには、gc_allocator を使用する必要があります。

書く代わりに

std::vector<MyType>

書かなければならない 

std::vector<MyType,gc_allocator<MyType> >

次のようなものを定義する方法はありますか

template<class T> typedef std::vector<T,gc_allocator<T> > gc_vector<T>;

少し前に確認したところ、それは不可能であることがわかりました。しかし、私は間違っていたかもしれませんし、別の方法があるかもしれません。

このようにマップを定義することは、特に不快です。

std::map<Key,Val>

になる

std::map<Key,Val, std::less<Key>, gc_allocator< std::pair<const Key, Val> > >

編集:マクロの使用を試みた後、次のコードがそれを壊すことがわかりました:

#define gc_vector(T) std::vector<T, gc_allocator<T> >
typedef gc_vector( std::pair< int, float > ) MyVector;

テンプレート化された型定義内のコンマは、マクロ引数の区切り記号として解釈されます。

したがって、内部クラス/構造体が最適なソリューションのようです。

C++0X での実行方法の例を次に示します。

// standard vector using my allocator
template<class T>
using gc_vector = std::vector<T, gc_allocator<T> >;

// allocates elements using My_alloc
gc_vector <double> fib = { 1, 2, 3, 5, 8, 13 };

// verbose and fib are of the same type
vector<int, gc_vector <int>> verbose = fib;
4

4 に答える 4

35

「テンプレート化された typedef」は使用できませんが、内部型で便利なクラス/構造体を使用できます。

template<typename T>
struct TypeHelper{
    typedef std::vector<T,gc_allocator<T> > Vector;
};

そして、コードで使用します

TypeHelper<MyType>::Vector v;
TypeHelper<MyType>::Vector::iterator it;

そして、マップに似たもの：

template<typename K,typename V>
struct MapHelper{
    typedef std::map<K, V, gc_allocator<K,V> > Map;
};

編集 - @Vijay: 別の回避策があるかどうかはわかりません。マクロを使用すると、よりコンパクトな表記法が得られるかもしれませんが、個人的には好きではありません。

#define GCVECTOR(T) std::vector<T,gc_allocator<T> >

TypeHelper編集 - @chmike: このソリューションでは、コンストラクターを再定義する必要がないことに注意してください。

于 2009-03-16T09:18:14.800 に答える
8

以下をパブリックに継承できます。

template<class T>
class gc_vector<T> : public std::vector<T, gc_allocator<T> >
{
    public:
    // You'll have to redeclare all std::vector's constructors here so that
    // they just pass arguments to corresponding constructors of std::vector
};

これで問題は完全に解決します。派生型は、基本型を使用できる場所ならどこでも使用でき、まともなコンパイラを使用しても実装のオーバーヘッドはありません。

std::vector に非仮想デストラクタがあるという事実は、基本クラス変数へのポインタを介して派生クラス変数を削除しようとすると、C++ 標準に従って未定義の動作につながる可能性があります。

実際には、これはこの特定のケースでは問題になりません。派生クラスには、基本クラスと比較して新しいものが追加されていないため、派生クラスのデストラクタは基本クラスのデストラクタを呼び出すだけです。パラノイアで進め、とにかく慎重に移植。

このクラス変数をヒープに割り当てない場合 (そして、ベクター変数をスタック上および他のクラスのメンバーとして割り当てるのが一般的です)、非仮想デストラクタの問題は影響しません。

于 2009-03-16T09:18:51.790 に答える
1

コンパイラを限界まで押し上げたい場合は、マクロを使用して実行できます。Java の「Future」クラスと「Callable」クラスに相当する C++ を実装しているときにそれを行いました。私たちのライブラリは参照カウント オブジェクトを使用するため、"Reference<T>" 自体がテンプレート クラスであり、"T" は "ReferencedObject" から派生します。

1. Create your template Classes. Mine are:

    template<typename T>
    class Callable {
    private:

    public:
        virtual T Call() = 0;
    };

    template<typename T> CountedFuture : public ReferencedObject {
    private:
       Callable<T>* theTask;
       T            theResult;

    public:
       T Get() { 
          // Run task if necessary ...
          if(task) {
             theResult = theTask->Call();
             delete theTask;
          }
          return theResult;
       }
    };

2. In the application code I'm using references, so I define the macro:

   #define Future(T) Reference<CountedFuture<T>>

これの美しさは、マクロが「テンプレート typedef」から望むことを正確に実行することです。欠点は、型パラメーターに「<>」を使用できず、型推論がないことです。 .

3. I can now use the Macro wherever I would use a template, like in functions:

   Future(char*) DoSomething() { ... }
   bool          TestSomething(Future(std::string) f) { .... }
于 2012-01-30T22:49:19.453 に答える