Herzlich Willkommen, lieber Gast!
  Sie befinden sich hier:

  Forum » C / C++ (ANSI-Standard) » Template Bedingt beim compilieren auflaufen lassen.

Forum | Hilfe | Team | Links | Impressum | > Suche < | Mitglieder | Registrieren | Einloggen
  Quicklinks: MSDN-Online || STL || clib Reference Grundlagen || Literatur || E-Books || Zubehör || > F.A.Q. < || Downloads   

Autor Thread - Seiten: > 1 < [ 2 ]
000
24.06.2004, 18:15 Uhr
RHBaum



Ich weiss ich hab schon mal was drueber gelesen, aber weiss nimmer wo ...

folgendes Problem, ich hab nen Template folgender bauart:


C++:
template<class TValue = unsigned long, size_t DSize = sizeof(TValue)>
class MyClass ...



folgende Bedingung ... die Groese des Datentyps TValue in Byte muss groesser oder gleich dem Disze Parameter sein ... der DSize Parameter darf ned 0 sein ...
Wenn diese bedingung verletzt wird, soll der compiler das ned uebersetzen ... (welcher fehler an sich ist egal) . es muss mit dem Vc++ 6.0 compiler gehen ...

Wie krieg ich das am besten hin ?
Oder weiss wer wo ich sowas gelesen hab ???

Also ...

C++:
MyClass <unsigned long,4>  // soll gehen
MyClass <long,3>  // soll gehen
MyClass <void *,1>  // soll gehen
MyClass <unsigned long,0>  // soll nicht compilieren
MyClass <unsigned long,5>  // soll nicht compilieren (Datentyp zu klein ... oder size zu gross :wink:  )



Ciao ...

Dieser Post wurde am 24.06.2004 um 18:16 Uhr von RHBaum editiert.
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
001
24.06.2004, 18:48 Uhr
0xdeadbeef
Gott
(Operator)


Wie wärs damit:

C++:
#include "boost/mpl/bool.hpp"
#include "boost/mpl/if.hpp"

template<typename _t = unsigned long, size_t _dsize = sizeof(_t)>
class my_class {
private:
  inline void _aux_assert_valid_dsize(_t const * const) const { }
  inline void assert_valid_dsize() const {
    _aux_assert_valid_dsize(boost::mpl::if_<boost::mpl::bool_<_dsize != 0 &&
                                                              _dsize <= sizeof(_t)> ,
                                            _t*,
                                            _t**>::type(0));
  }

public:
  my_class() { assert_valid_dsize(); }
};

int main() {
  my_class<unsigned long, 3> m;
  //  my_class<unsigned long, 5> n;
  //  my_class<unsigned long, 0> o;
}


Wenn die Bedingung nicht erfüllt ist, versucht er _aux_assert_valid_dsize mit nem t** aufzurufen, was nicht geht, weil der Prototyp nicht da ist. Ist vielleicht nicht die hübscheste Konstruktion, aber naja - darauf sollte man aufbauen können.
--
Einfachheit ist Voraussetzung für Zuverlässigkeit.
-- Edsger Wybe Dijkstra

Dieser Post wurde am 24.06.2004 um 18:53 Uhr von 0xdeadbeef editiert.
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
002
24.06.2004, 18:53 Uhr
virtual
Sexiest Bit alive
(Operator)


Hm,

würde mich auch interessieren. Spontan einfallen tut mir nämlich nur:

C++:
template<class TValue, size_t DSize>
class MyClass
{
     typedef char dummy_type[(DSize/DSize)*sizeof(TValue)-DSize+1];
     ...
};


Wobei das (DSize/DSize) fortgelassen werden kann, wenn DSize 0 sein darf
--
Gruß, virtual
Quote of the Month
Ich eß' nur was ein Gesicht hat (Creme 21)
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
003
24.06.2004, 18:55 Uhr
virtual
Sexiest Bit alive
(Operator)


@Beefy
Na, neuerdings Boost fan?
Nur glaube ich - ohne es ausprobiert zu haben - das der Code immer kompiliert. Die Anforderung war aber einen Code zu haben, der nur bedingt compiliert. Täusche ich mich?
--
Gruß, virtual
Quote of the Month
Ich eß' nur was ein Gesicht hat (Creme 21)
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
004
24.06.2004, 18:59 Uhr
0xdeadbeef
Gott
(Operator)


Ja, das war die Anforderung, und das macht der auch.
--
Einfachheit ist Voraussetzung für Zuverlässigkeit.
-- Edsger Wybe Dijkstra
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
005
24.06.2004, 19:11 Uhr
0xdeadbeef
Gott
(Operator)



C++:
#include "boost/mpl/bool.hpp"
#include "boost/mpl/if.hpp"

template<typename _t = unsigned long, size_t _dsize = sizeof(_t)>
class my_class {
private:
  struct empty_struct {};
  struct assert_valid_dsize
    : boost::mpl::if_<boost::mpl::bool_<_dsize != 0 && _dsize <= sizeof(_t)>,
                      empty_struct,
                      int>::type {};
  static assert_valid_dsize _a_dsize;

public:
  my_class() { }
};

int main() {
  my_class<unsigned long, 3> m;
  my_class<unsigned long, 5> n;
  my_class<unsigned long, 0> o;
}


--
Einfachheit ist Voraussetzung für Zuverlässigkeit.
-- Edsger Wybe Dijkstra

Dieser Post wurde am 24.06.2004 um 19:12 Uhr von 0xdeadbeef editiert.
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
006
24.06.2004, 20:07 Uhr
virtual
Sexiest Bit alive
(Operator)


Ja, seh ich jetzt auch. Würden wir jetzt golfen, hätte ich aber gewonnen
--
Gruß, virtual
Quote of the Month
Ich eß' nur was ein Gesicht hat (Creme 21)
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
007
24.06.2004, 20:36 Uhr
0xdeadbeef
Gott
(Operator)


Das mag ja sein, aber gerade bei sowas, was eh schon nicht sonderlich übersichtlich ist, würde ich auf dreckige Hacks eher verzichten.
--
Einfachheit ist Voraussetzung für Zuverlässigkeit.
-- Edsger Wybe Dijkstra
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
008
24.06.2004, 21:04 Uhr
virtual
Sexiest Bit alive
(Operator)


Was ist dreckig?
Ich finde meine Lösung schon fast eleganter, weil sie wirklich rein typbasiert ist. Die von Dir vorgeschlagene Lösung braucht immer noch einen Static member (_a_dsize). Okay, wir können uns jetzt über den Ausdruck "(DSize/DSize)*sizeof(TValue)-DSize+1" Streiten. Wenn man den aber umformuliert in "DSize>0 && DSize<=sizeof(TValue)", also alles in allem

C++:
template<class TValue, size_t DSize>
class MyClass
{
     // Asserts, whether TValue and DSize are consistent. Causes a compiler error if not.
     typedef char template_parameter_checker[DSize>0 && DSize<=sizeof(TValue)];
     ...
};


so würde ich das deiner Lösung vorziehen, weil kurz, kaum zweideutig und unabh. von 3rd party Produkten wie boost.
--
Gruß, virtual
Quote of the Month
Ich eß' nur was ein Gesicht hat (Creme 21)
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
009
24.06.2004, 23:23 Uhr
0xdeadbeef
Gott
(Operator)


Hm. OK, da hast du recht.
--
Einfachheit ist Voraussetzung für Zuverlässigkeit.
-- Edsger Wybe Dijkstra
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
Seiten: > 1 < [ 2 ]     [ C / C++ (ANSI-Standard) ]  


ThWBoard 2.73 FloSoft-Edition
© by Paul Baecher & Felix Gonschorek (www.thwboard.de)

Anpassungen des Forums
© by Flo-Soft (www.flo-soft.de)

Sie sind Besucher: