12

別のテンプレートの問題にぶつかりました:

問題: オブジェクトがポインターである場合に備えて、コンテナー クラス (foo) を部分的に特殊化したいのですが、delete メソッドだけを特殊化したいのです。次のようになります。

ライブラリコード

template <typename T>
class foo
{
public:
    void addSome    (T o) { printf ("adding that object..."); }
    void deleteSome (T o) { printf ("deleting that object..."); }
};

template <typename T>
class foo <T *>
{
public:
    void deleteSome (T* o) { printf ("deleting that PTR to an object..."); }
};

ユーザーコード

foo<myclass> myclasses;
foo<myclass*> myptrs;

myptrs.addSome (new myclass());

これにより、myptrs には addSome というメソッドがないことがコンパイラに通知されます。なんで ？

ありがとう。

解決

ここでのトニーの答えに基づいて、完全にコンパイル可能なもの

ライブラリ

template <typename T>
class foobase
{
public:
    void addSome    (T o) { printf ("adding that object..."); }
    void deleteSome (T o) { printf ("deleting that object..."); }
};


template <typename T>
class foo : public foobase<T>
{ };

template <typename T>
class foo<T *> : public foobase<T *>
{
public:
    void deleteSome (T* o) { printf ("deleting that ptr to an object..."); }
};

ユーザー

foo<int>    fi;
foo<int*>   fpi;

int         i = 13;

fi.addSome (12);            
fpi.addSome (&i);

fpi.deleteSome (12);        // compiler-error: doesnt work
fi.deleteSome (&i);         // compiler-error: doesnt work
fi.deleteSome (12);         // foobase::deleteSome called
fpi.deleteSome (&i);        // foo<T*>::deleteSome called
4

5 に答える 5

11

2番目の解決策（正しいもの）

template <typename T>
class foo
{
public:
    void addSome    (T o) { printf ("adding that object..."); } 
    void deleteSome(T o) { deleteSomeHelper<T>()(o); }
protected:
    template<typename TX> 
    struct deleteSomeHelper { void operator()(TX& o) { printf ("deleting that object..."); } };
    template<typename TX> 
    struct deleteSomeHelper<TX*> { void operator()(TX*& o) { printf ("deleting that PTR to an object..."); } };
};

このソリューションは、 Core Issue＃727に従って有効です。

最初の（間違った）解決策:(コメントがそれを参照しているのでこれを維持しました）

クラスの一部だけを専門にすることはできません。deleteSomeあなたの場合、最良の方法は次のように関数をオーバーロードすることです。

template <typename T>
class foo
{
public:
    void addSome    (T o) { printf ("adding that object..."); }
    void deleteSome (T o) { printf ("deleting that object..."); }
    void deleteSome (T* o) { printf ("deleting that object..."); }
};
于 2009-11-18T17:51:44.880 に答える
10

別の解決策。補助機能を使用しますdeleteSomeHelp。

template <typename T>
class foo {
 public:    
   void addSome    (T o) { printf ("adding that object..."); 
   template<class R>
   void deleteSomeHelp (R   o) { printf ("deleting that object..."); }};
   template<class R>
   void deleteSomeHelp (R * o) { printf ("deleting that PTR to an object..."); }};
   void deleteSome (T o) { deleteSomeHelp(o); }
}
于 2009-11-18T18:21:09.517 に答える
3

enable_ifブーストのを使用して、継承is_sameやremove_pointerその他の手間をかけずに、クラスで2つの関数を取得するこのソリューションはまだ見ていません。

のみを使用したバージョンについては、以下を参照してくださいremove_pointer。

#include <boost\utility\enable_if.hpp>
#include <boost\type_traits\is_same.hpp>
#include <boost\type_traits\remove_pointer.hpp>

template <typename T>
class foo
{
public:
    typedef typename boost::remove_pointer<T>::type T_noptr;

    void addSome    (T o) { printf ("adding that object..."); }

    template<typename U>
    void deleteSome (U o, typename boost::enable_if<boost::is_same<T_noptr, U>>::type* dummy = 0) { 
        printf ("deleting that object..."); 
    }
    template<typename U>
    void deleteSome (U* o, typename boost::enable_if<boost::is_same<T_noptr, U>>::type* dummy = 0) { 
        printf ("deleting that PTR to that object..."); 
    }
};

簡略化されたバージョンは次のとおりです。

#include <cstdio>
#include <boost\type_traits\remove_pointer.hpp>

template <typename T>
class foo
{
public:
    typedef typename boost::remove_pointer<T>::type T_value;

    void addSome    (T o) { printf ("adding that object..."); }

    void deleteSome (T_value& o) { // need ref to avoid auto-conv of double->int
        printf ("deleting that object..."); 
    }

    void deleteSome (T_value* o) { 
        printf ("deleting that PTR to that object..."); 
    }
};

そして、MSVC 9 で動作します: (エラーが発生する行はコメントアウトされていますが、それらは正しくないため、テストのために持っておくとよいでしょう)

void main()
{
   foo<int> x;
   foo<int*> y;

   int a;
   float b;

   x.deleteSome(a);
   x.deleteSome(&a);
   //x.deleteSome(b); // doesn't compile, as it shouldn't
   //x.deleteSome(&b);
   y.deleteSome(a);
   y.deleteSome(&a);
   //y.deleteSome(b);
   //y.deleteSome(&b);
}
于 2009-11-18T18:52:34.063 に答える
2

単一機能の基本クラスを作成するdeleteSome

template<class T>
class base {
public:
  void deleteSome (T o) { printf ("deleting that object..."); }
}

部分的な特殊化を行う

template<class T>
class base<T*> {
public:
  void deleteSome (T * o) { printf ("deleting that PTR to an object..."); }
}

基本クラスを使用する

template <typename T>
class foo : public base<T> {
 public:    
   void addSome    (T o) { printf ("adding that object..."); 
}
于 2009-11-18T18:10:06.247 に答える
1

継承を使用してこれを機能させることができます：

template <typename T>
class foobase
{
public:
    void addSome    (T o) { printf ("adding that object..."); }
    void deleteSome (T o) { printf ("deleting that object..."); }
};

template <typename T>
class foo : public foobase<T>
{ };

template <typename T>
class foo <T *> : public foobase<T>
{
public:
    void deleteSome (T* o) { printf ("deleting that PTR to an object..."); }
};
于 2009-11-18T17:54:55.210 に答える