template<typename T_Type>
class Container
{
private:

    template<typename T_Allow>
    class Allow
    {
    public:
        void allow()
        {};
    };

    template<typename T_Allow>
    class Allow<T_Allow*>
    {
    private:
        void allow()
        {
            #pragma message("operator= bei Zeigern nicht erlaubt")
        };
    };

public:

    Container<T_Type>& operator=(const Container<T_Type> &rhs)
    {
        Allow<T_Type>::allow();
        //Kopierarbeiten
    };
};

Gäbe es noch eine andere bzw bessere Lösung um beim Aufruf des = Operators für bestimte Typen direkt beim Compilen einen Fehler hervorzurufen?

Gäbe es noch eine andere bzw bessere Lösung um beim Aufruf des = Operators für bestimte Typen direkt beim Compilen einen Fehler hervorzurufen?

Du verlässt Dich darauf, dass das pragma erst beim Instanziieren des Templates behandelt wird und nicht schon vorher. Das mag bei MSVC noch funktionieren, bei allen anderen Compilern wahrscheinlich nicht, da pragmas sowieso implementierungsabhängig sind.

template <typename T>
class AssignHelper {};

template <typename T>
class AssignHelper<T*>
{
private:
    void operator=(AssignHelper&);
};

template<typename T>
class Container : AssignHelper<T>
{
};

Sofern der implizt deklarierte Zuweisungsoperator ausreicht.

Muss der Zuweisungsoperator selbst definiert werden, z.B. so

template<typename T>
class Container
{
    Container& operator=(const Container& rhs)
    {
        BOOST_STATIC_ASSERT( !boost::is_pointer<T>::value ); // oder
        int dummy[!boost::is_pointer<T>::value];dummy; // o.ä.
        ...
    }
};

template<typename T_Type>
class Container
{
public:

    boost::disable_if<boost::is_pointer<T_Type>, Container<T_Type>&>::type //liefert Container<T_Type>& falls T_Type kein Pointer ist, sonst Compilererror
    operator=(const Container<T_Type> &rhs)
    {
        //Kopierarbeiten
    };
};

// Benötigte Boost-Header
#include <boost/utility/enable_if.hpp>
#include <boost/type_traits/is_pointer.hpp>

template<typename T_Type> 
class Container 
{ 
public: 
    // hier
    typename boost::disable_if<boost::is_pointer<T_Type>, Container<T_Type>&>::type
    operator=(const Container<T_Type> &rhs) 
    { 

    }
};

Oder simpel mit boost::disavle_if :

Allerdings ist der Operator kein Template, also gibt es auch kein SFINAE. Eine Funktionstemplate wiederum verhindert nicht die implizite Deklaration der normalen Operatorfunktion.

pumuckl schrieb:

Oder simpel mit boost::disavle_if :

Allerdings ist der Operator kein Template, also gibt es auch kein SFINAE. Eine Funktionstemplate wiederum verhindert nicht die implizite Deklaration der normalen Operatorfunktion.

und ich dachte immer Memberfunktionen und damit auch der op= von Klassentemplates sind automatisch auch Templates.
MSVC schluckt das jedenfalls ohne zu meckern (was natürlich nicht unbedingt was heißt bei templates)

camper schrieb:

Vergiss #pragma oder such dir ein anderes Unterforum aus.

Was hat pragma bitte mit nem anderen unterforum zu tun?

The #pragma directives offer a way for each compiler to offer machine- and operating system-specific features [...] Pragmas are machine- or operating system-specific by definition, and are usually different for every compiler.

(Quelle: MSDN)

template<typename T>
class ContainerBase
{
protected:
    //ctor
    //copy ctor
    //= operator
};

template<typename T>
class Container:public ContainerBase<T>
{
public:
    //ctor
    //copy ctor
    //= operator
};

template<typename T>
class Container<T*>:public ContainerBase<T*>
{
private:
    //copy ctor
    //= operator
public:
    //ctor
};

Liefert genau das was ich wollte. Container mit Zeiegrn sind nicht kopierbar und die Fehlermeldungen sind etwas genauer als bei boost static_assert.

Danke nochmal an alle für die Hilfe.