template </*...*/>
class X {
    void read(/*...*/) { /*...*/ }
    void write(/*...*/) { /*...*/ }
}

Ich würde gerne, mittels eines Templatearguments, nur schreiben, lesen oder beides.
Kann ich dem Compiler dazu bringen mir dann auch einen Fehler zu werfen, bei falscher Benutzung?
sozusagen ein ios_base::openmode zur Kompilierzeit.
Geht das überhaupt? Wenn nicht, was gäb es für gute Alternativen?

enum class openmode
{
    read,
    write
};

template <openmode>
class X 
{
};

template<>
class X<openmode::read>
{
    void read(/*...*/) { /*...*/ }
};

template<>
class X<openmode::write>
{
    void write(/*...*/) { /*...*/ }
};

(Ungetestet, C++11)

Statt bool könntest du natürlich auch Flags nehmen.

[Edit] ::type vergessen

oder beides.

Hab ich übersehen. :xmas1:

Passe meine Lösung an.

Edit: Nimm gleich Nexus', meine läuft auch nur aufs ableiten hinaus..

struct Reader 
{ 
    void read(); 
}; 

struct Writer 
{ 
    void write(); 
};   

template <tyename... StreamPolicies> 
struct X : public StreamPolicies... 
{ 
};

template <OpenMode OM>
struct X
{ 
  typename std::enable_if<OM & Read>::type read();
  typename std::enable_if<OM & Write>::type write();

  bool is_open() const;
};

Hat den Vorteil, dass manche Methoden von beiden benutzt werden können (is_open).

Ganz anderer Ansatz:

template <OpenMode OM>
struct X
{ 
  typename std::enable_if<OM & Read>::type read();
  typename std::enable_if<OM & Write>::type write();

  bool is_open() const;
};

Hat den Vorteil, dass manche Methoden von beiden benutzt werden können (is_open).

Das wird nicht funktionieren.

Das wird nicht funktionieren.

Stimmt, da braucht es etwas mehr Aufwand:

template <bool R, bool W>
struct X {
  template <bool Enabled = R,
            typename = typename std::enable_if<Enabled>::type>
  void read() {}
  template <bool Enabled = W,
            typename = typename std::enable_if<Enabled>::type>
  void write() {}
  bool is_open() const {};
};

Jetzt geht es aber.

EDIT: Der Fehler ist aber nicht eindeutig / unverständlich

struct wrong {
    virtual void _f() = 0;
};

template <bool R, bool W>
struct X 
{
    typename std::conditional<R, int, wrong>::type read() {
        /* ... */
        return 0;
    }

    typename std::conditional<W, int, wrong>::type write() {
        /* ... */
        return 0;
    }
};

EDIT 2: Die Lösung von "enabler" ist sehr viel schöner.

Sone schrieb:

Das wird nicht funktionieren.

Stimmt, da braucht es etwas mehr Aufwand:

template <bool R, bool W>
struct X {
  template <bool Enabled = R,
            typename = typename std::enable_if<Enabled>::type>
  void read() {}
  template <bool Enabled = W,
            typename = typename std::enable_if<Enabled>::type>
  void write() {}
  bool is_open() const {};
};

Jetzt geht es aber.

Ja, aber das ganze mit SFINAE zu lösen ist irgendwie voll Overkill, findest du nicht?
Ich finde Nexus' Lösung ist die beste.

template <bool R, bool W>
struct X {
  void read()
  {
      static_assert( R, "read not enable for this type!" );
      // ...
  }
  void write()
  {
      static_assert( W, "write not enable for this type!" );
      // ...
  }
  bool is_open() const {};
};

?

Ein einfaches static_assert dürfte es schon tun

Bzw. Bei C++98/03 einfach [c]BOOST_REQUIRE_MESSAGE[/c] BOOST_STATIC_ASSERT .

Ok, campers ist die Beste.

Ein einfaches static_assert dürfte es schon tun

Bzw. Bei C++98/03 einfach BOOST_REQUIRE_MESSAGE .

Was soll BOOST_REQUIRE_MESSAGE in dem Zusammenhang? Das ist aus Boost.Test und macht einen RUNTIME Check. Also vollkommen daneben.

Wenn static_assert nicht verfügbar ist nimmt man einfach BOOST_STATIC_ASSERT .

Was spricht gegen [static_assert]?

Das habe ich mir auch überlegt, war aber verunsichert, was den Auswertungszeitpunkt angeht.

Ist es also garantiert, dass static_assert erst angeschaut wird, wenn die entsprechende Methode instanziiert wird?

Ist es also garantiert, dass static_assert erst angeschaut wird, wenn die entsprechende Methode instanziiert wird?

Nein. In diesem Falle ist aber die Bedingung vom Templateparameter abhängig und kann folglich erst bei der Instantiierung ausgewertet werden.

Sone schrieb:

Ok, campers ist die Beste.

Ein einfaches static_assert dürfte es schon tun

Bzw. Bei C++98/03 einfach BOOST_REQUIRE_MESSAGE .

Was soll BOOST_REQUIRE_MESSAGE in dem Zusammenhang? Das ist aus Boost.Test und macht einen RUNTIME Check. Also vollkommen daneben.

Ups.
Hab es nur einige Sekunden vorher benutzt, deswegen die Verwechselung :xmas2:

Muss natürlich ~_STATIC_ASSERT sein.

Nexus schrieb:

Ist es also garantiert, dass static_assert erst angeschaut wird, wenn die entsprechende Methode instanziiert wird?

Nein. In diesem Falle ist aber die Bedingung vom Templateparameter abhängig und kann folglich erst bei der Instantiierung ausgewertet werden.

aber die sind doch in dem Moment vorhanden wo die Klasse instanziiert wird. Und zum Beispiel der gcc versucht dann jede Funktion zu instanziieren, selbst wenn sie nicht aufgerufen wird.

camper schrieb:

Nexus schrieb:

Ist es also garantiert, dass static_assert erst angeschaut wird, wenn die entsprechende Methode instanziiert wird?

Nein. In diesem Falle ist aber die Bedingung vom Templateparameter abhängig und kann folglich erst bei der Instantiierung ausgewertet werden.

aber die sind doch in dem Moment vorhanden wo die Klasse instanziiert wird. Und zum Beispiel der gcc versucht dann jede Funktion zu instanziieren, selbst wenn sie nicht aufgerufen wird.

Darf er das laut Standard überhaupt?

aber die sind doch in dem Moment vorhanden wo die Klasse instanziiert wird. Und zum Beispiel der gcc versucht dann jede Funktion zu instanziieren, selbst wenn sie nicht aufgerufen wird.

Sollte er eigentlich nicht, sofern es nicht eine explizite Instantiierung der Klasse oder aber die Funktion selbst virtuell ist.

The implicit instantiation of a class template specialization causes the implicit instantiation of the declarations, but not of the definitions or default arguments, of the class member functions

Ist das der richtige Teil?

<strong>N3337 §14.7.1 / 1</strong> schrieb:

The implicit instantiation of a class template specialization causes the implicit instantiation of the declarations, but not of the definitions or default arguments, of the class member functions

Ist das der richtige Teil?

ja

template <bool R, bool W>
struct X {
  void read()
  {
      static_assert( R, "read not enable for this type!" );
      // ...
  }
  void write()
  {
      static_assert( W, "write not enable for this type!" );
      // ...
  }
  bool is_open() const {};
};

X<false,false> a;
X<false,true> b;
X<true,false> c;
X<true,true> d;

//template struct X<false,false>;

int main() {}

wird anstandslos von g++ 4.3.6, 4.4.7, 4.5.4, 4.6.3, 4.7.2, 4.8.0 (20121216) und clang++ 3.2 kompiliert.
Eine explizite Instantiierung (außer <true,true>) oder die Deklaration als virtuelle Funktion führt dagegen zum Fehler.

Deshalb gefaellt mir Nexus' Variante am besten - da sie flexibel ist.

Bei read/write koennte ich ja zB eine datei einmal als readonly, writeonly und einmal als read/write oeffnen wollen...

Ich steh grad ziemlich aufm Schlauch oder du hast dich vertan.

[Danke für das Brainstorming]