Probleme mit Templates

Hallo!

Ich habe folgende überladene Methode:

in blabla.cpp

void Blabla::setWert( const unsigned char *buffer, unsigned short len ){

   data = new unsigned char[len]; //data ist Membervariable der Klasse blabla

   memcpy( data, buffer, len );
}

void Blabla::setWert( const unsigned short buffer ){

   data = new unsigned char[sizeof(buffer)];

   memcpy( data, &buffer, sizeof(buffer) );
}

Jetzt wollte ich aber anstatt die Methode zu überladen template benutzen. In dieser Art.

template <typedef T>
void Blabla::setWert( const T& buffer, unsigned short len ){

   data = new unsigned char[len];

   memcpy( data, buffer, len );
}

Hab das auch schon versucht aber nicht hinbekommen. Hatte immer Probleme mit den Referenzen (von buffer). Wie muss die Methode denn genau aussehen als template? Oder funktioniert das gar nicht wie ich es mir vorstelle???

rüdiger

template<typename name>

oder

template<class name>

aber nicht

template<typedef name>

.

Ähm, Referenzen sind was anderes als Pointer! Schreib doch einfach

const T *buffer

btw. solltest du anstelle von unsigned short lieber (std::)size_t für größen Informationen benutzen, so vermeidest du einige (Sicherheits) Probleme

whoops...das sollte natürlich typename heißen und nicht typedef - war nur ein schneller Tippfehler.

Wenn ich

const T *buffer

schreibe, dann bekomm ich doch Probleme wenn ich nun der Methode ein unsigned short oder auch size_t übergeben will!?

rüdiger

nö, solltest keine Probleme bekommen

Mr. N

mmh, nur mal nebenbei:
T const * ist konsequenter als const T *.

operator void

Wenn len die Länge des Buffers in chars ist, kannst du als ersten Parameter auch gleich void* annehmen und dir das template sparen... dann hättest du die erste Funktion verallgemeinert und könntest sie trotzdem in die .cpp verlegen. Für die zweite musst du dann entweder immer die erste mit (&var, sizeof(var)) aufrufen oder dir dafür ein template schreiben:

template<typename T> 
void Blabla::setWert(const T& buffer)
{
    setWert(&buffer, sizeof(T));
}

Wenn du unbedingt beide auf einen template-Nenner bringen willst, könntest du die Funktion so schreiben:

template<typename T>
void Blabla::setWert(const T* buffer, std::size_t len = sizeof(T))
{
   data = new unsigned char[len];
   memcpy(data, buffer, len); 
}

Und die dann entweder mit setWert(&eineVariable) oder setWert(array, sizeof(array)) aufrufen.

Mr. N schrieb:

T const * ist konsequenter als const T *.

Und const T* ist leichter von T const* zu unterscheiden *find*.

Mr. N

operator void schrieb:

Mr. N schrieb:

T const * ist konsequenter als const T *.

Und const T* ist leichter von T const* zu unterscheiden *find*.

hihi.
const T * und T const * ist das gleiche.
T * const jedoch ist was andres.
und T const * const ist das gleiche wie const T * const.

operator void

Ächz. Blöder Vertipper, aber man könnte ihn als Bestätigung meines Arguments sehen Ich meinte natürlich const T* und T* const.

Mr. N

@operator void: Gut, das is natürlich Geschmackssache... aber T const * statt T * const ist bei mir ein _sehr_ seltener typo.

operator void

Mir geht's weniger ums Tippen, eher ums Schnelle lesen... wenn das schöne blaue const mal ausnahmsweise weit hinten steht, sehe ich gleich "oh, sowas, ein konstanter Zeiger, die gibt es ja auch noch"