Richtige Variablendefinition

vi.p

Hallo Leute!

Es gibt in C++ ja eine große Auswahl an Datentypen. Man kann sie mit long, short unsigned, signed usw. kombinieren.

Meine eigentliche Frage: Achtet ihr darauf, dass ihr jede Variable auf ihr Einsatzgebiet "zuschneidet"? Beispielsweise eine Zählvariable, die von 0 - 20 zählt als unsigned short zu definieren, anstatt als int. Genauso Membervariablen, von denen man weiß, dass sie nur einen kleinen Wert haben. Oder auch Rückgabewerte.

Wie handhabt ihr das?

Keep smilin'
vi.p

rüdiger

Beispielsweise eine Zählvariable, die von 0 - 20 zählt als unsigned short zu definieren, anstatt als int.

short zu nehmen ist oft keine gute Wahl, da der Code für größere Typen oft schneller ist! Auf die Größe zu achten ist auf normalen Rechnern nur dann sinnvoll, wenn man die Daten binär lesen/schreiben will oder auf die Größe angewiesen ist.

Ich achte aber darauf für Zähler und Größenangaben stehts unsigned Typen (enstprechend eben std::size_t ) zu nehmen, um potentielle Fehler auszuschließen.

Blue-Tiger

Hmm... na ja, relativ selten eigentlich. Ich nehm's eher woertlich. Char fuer ASCII oder einzelne Bytes, Integers fuer alle moeglichen Zahlen, unsigned int oder long wenn ich groessere Zahlen brauch und float fuer fliesskomma (und ganz selten auch mal double).

BTW waer in deinem Beispiel (0 - 20) ein char wesentlich besser geeignet als ein short
Wenn du's wirklich genau nehmen willst, wuerd sich wohl http://boost.org/libs/integer/cstdint.htm anbieten.

Ich achte aber darauf für Zähler und Größenangaben stehts unsigned Typen (enstprechend eben std::size_t ) zu nehmen, um potentielle Fehler auszuschließen.

Wo ist std::size_t eigentlich definiert? in <cstddef>, oder ist das ein anderes size_t ?

Artchi

Als bei primitiven Type, nehme ich immer einfach int. Das passt irgendwie immer. Solange ich keine direkten Bitmanipulationen brauche, ist das auch i.O. Gefährlich wirds, wenn man Bits manipulieren will, dann muß man sich für einen speziellen Typ entscheiden.

std::size_t ist in einem C++-Header drin. size_t wird vom Compiler bereit gestellt, und ist glaube ich ein C-Sprachmerkmal.

rüdiger

Blue-Tiger schrieb:

Ich achte aber darauf für Zähler und Größenangaben stehts unsigned Typen (enstprechend eben std::size_t ) zu nehmen, um potentielle Fehler auszuschließen.

Wo ist std::size_t eigentlich definiert? in <cstddef>, oder ist das ein anderes size_t ?

in cstddef

@Artchi
size_t ist ein typedef in C eben in stddef.h und in C++ eben in cstddef (und namespace std)

thordk

ich machs eigentlich andersrum: ich versuch so wenige typen wie möglich zu verwenden.

in den allermeisten fällen reichen int , char und bool (die ersten beide manchmal mit unsigned modifier). wozu noch mehr verwenden? die meisten compiler werden dir aus dem sorgfältig ausgewähltem short eh nen int (oder "int64") drehen, wenn du ihm nich auf die finger haust.

Badestrand

Ich finde, unsigned-Werte eignen sich nur, um casts zu vermeiden oder weniger Abfragen machen zu müssen.
Bei so einer Funktion wäre z.B. unsigned (ein bissl) sinnvoller:

Version 'unsigned':

char GetValue( unsigned int Index )
{
    char Vals[] = { 'g', 'z', 'o', 'p' };
    if ( Index < sizeof(Vals)/sizeof(char) )
        return Vals[Index];
    return '\0';
}

Version 'signed':

char GetValue( int Index )
{
    char Vals[] = { 'g', 'z', 'o', 'p' };
    if ( Index > 0  &&  Index < sizeof(Vals)/sizeof(char) )
        return Vals[Index];
    return '\0';
}