3. default Typ bei Vektoren?

default Typ bei Vektoren?

  • N

    Technohead schrieb:

    Also wenn jetzt hier schon meine Schreibweise so groß niedergemacht wird 😉 hättet ihr vielleicht einen Link zu einem anständigen C++ Style guide??

    Sowas gibt es sicher, aber das finde ich eine schlechte Idee. Sogenannten Style-Guides, die sich anmassen, den Programmierstil anderer vorschreiben zu können, würde ich jetzt nicht vertrauen.

    Programmierstil im Sinn von richtig einrücken, eine Anweisung pro Zeile, gut kommentieren etc. ist schon sinnvoll, da dadurch das Verständnis erleichtert wird. Aber Dinge wie Bezeichnernamen, besonders Gross-/Kleinschreibung, ist wohl eher Geschmackssache. Wichtig ist einfach, dass du konsistent bleibst.

    Technohead schrieb:

    Ach und wegen der Großschreibung: ich finde das sieht halt blöd aus, wenn man zum Beispiel iinteger schreibt.

    Du sollst auch nicht iinteger schreiben. 😉

    Es ging eher darum, dass iInteger kein guter Variablenname ist. Dass die Variable vom Typ int ist, sieht man bei ihrer Deklaration (bei moderneneren IDEs wie MSVC++ auch beim Darüberfahren der Maus). Diese Information musst du also nicht noch zusätzlich im Bezeichner ausdrücken, schon gar nicht doppelt. Sag lieber, wofür die Variable steht. Size ? Counter ? ID ?

    Was die Ungarische Notation (das kleine i am Anfang) betrifft: Davon rate ich persönlich ab. Erstens aus oben genanntem Grund, dass es redundante Information beinhaltet. Zweitens wirst du das sowieso nicht konsequent durchziehen können.

    Stell dir mal so etwas vor:

    std::vector<std::list<int*> >& refveclstpi_var; // ref=Referenz, vec=vector, lst=list, p=Pointer, i=int

    Du magst das jetzt als weit hergeholt sehen, aber auf so etwas wird es bei komplexeren Typen hinauslaufen. Deshalb würde ich von Anfang an von solchen Präfixen wegkommen. Das gilt auch für das "C" bei Klassen, wie CShip , CDocument etc. Was am ehesten noch legitim ist, ist ein vorgestelltes "m_" oder "my" für Member.

    Um vielleicht trotzdem einige Anregungen zu Variablennamen, insbesondere Gross-/Kleinschreibung zu geben:
    Die Standardbibliothek schreibt ja fast alles klein und trennt Wörter mit Unterstrichen ( push_back ).
    Ich selber mach verwende häufig CamelCase ( MyVariableName ), weil ich es ästhetisch finde. 🙂

    Was aber die meisten gleich handhaben, sind Makros. Diese werden fast immer vollständig grossgeschrieben und mit Unterstrichen getrennt ( ANY_MACRO ).

    Du solltest vielleicht ein bisschen herumexperimentieren; du wirst dann sehen, was dir am besten gefällt und am übersichtlichsten für dich ist. Hauptsache, du kommst von der Ungarischen Notation weg. 🙂

    0
  • T

    gut...dann wär das ja schonmal ein guter Ansatz für mich: Die UN in die Tonne kloppen. 🙂
    Dann aber noch eine andere Frage zu ein paar Style Sachen...nur mal eure Meinung hören:

    //1)
test(123,Test,dings);
//oder....
test(123, Test, dings);

//2)
void test(int wert){
}
//oder...
void test(int wert)
{
}

//3)
int i = 0;
bool IstDasJetztDings = true;

while(i < 500){
    int NochWas = 123;  

    test1();
    test2();
}

//oder...

int i = 0;
bool IstDasJetztDings = true;
while(i < 500){
    int NochWas = 123;  
    test1();
    test2();
}

//und noch ein letztes: 4)
while(i<200){}

//oder...

while(i < 200){}

    Ich werde letzendlich das machen, was Nexus empfohlen hat und herumexperimentieren...mich würde es nur halt mal interessieren, wie ihr das schreibt. Wenn ihr also bei Nummer 1 das erste eher nehmen würdet dann schreibt doch mal sowas wie 1)1 und so...dann wäre das auch schnell beantwortet 🙂

    0
  • ?

    ich schreib noch luftiger

    while( i < 200 )
{
  if( isTrue( true ) )
  {
    break;
  }
}

    bleibt letzlich aber geschmackssache.

    0
  • M

    Technohead schrieb:

    Wenn ihr also bei Nummer 1 das erste eher nehmen würdet dann schreibt doch mal sowas wie 1)1 und so...dann wäre das auch schnell beantwortet 🙂

    Ok, dann hier mal meine Antworten:

    1. 2 (Ich mache bei sowas immer ein Leerzeichen nach den Kommas, sonst sieht das ganze für mich so "zusammengequetscht" aus.)
    2. 2
    3. 2
    4. 2 (Aus dem selben Grund wie bei Nummer 1) ).

    Desweiteren würde Nummer 3) bei mir eher so aussehen:

    int i = 0;
bool ist_das_jetzt_dings = true;
// Hier kurzer Kommentar wofür die folgende Schleife gut sein soll
while(i < 500) {
    int noch_was = 123;  
    test1();
    test2();
}
    0
  • T

    @flubbidu: also beim Thema Geschmackssache: Ich find deins zu luftig 😉
    @Mizar: die Version von dir ist interessant 🙂

    Danke bisher für alle Antworten...das war eine sehr lehrreiche Diskussion 🙂 👍

    0
  • A

    Mizar schrieb:

    while(i < 500) {
    int noch_was = 123;  
    test1();
    test2();
}

    Ich habe einen Grund gegen diese Schleifensetzung, auch wenn sie nicht unüblich ist (in meiner Firma ist obiges Standard, wenn auch nicht für den eigentlichen Funktionsrumpf).

    a) Wenn man wie ich lange Zeilen umbricht und leicht einrückt, ist der Blick auf das Scope zumindestens etwas schwerer auf den ersten Blick zu übersehen
    b) Man vergisst eher mal die ein oder andere Klammer, gerade wenn man etwas geändert hat.

    for(std::map<int, std::string>::const_iterator it=myMap.begin(), end=myMap.end();
  it!=end; ++it)
{
    // tue etwas...
}

    Aber alles Geschmackssache (auch das mit dem Umbrechen).

    cu André

    0
  • T

    Beim Umbrechen ist das auch immer ne Frage der Bildschirmgröße 😃 😉 Ich werde einfach mal sehen, was schöner aussieht und praktikabler ist!! 👍

    0
  • A

    Technohead schrieb:

    Beim Umbrechen ist das auch immer ne Frage der Bildschirmgröße 😃

    Ich achte hier eher auf den [seltenen Fall] Druck (Umbruch nach 82 Zeichen hat sich bei mir recht bewährt), weil Ausdrucke mit den Automatischen Umbruch nicht sinnvoll lesbar sind.

    cu André

    0
  • N

    Wenn du meine Meinung auch noch hören willst: 😉

    // 1) 
test(123, Test, dings); 

// 2) 
void test(int wert) 
{ 
} 

//3) 
int i = 0; 
bool IstDasJetztDings = true; 

while(i < 500) // P.S. Endlosschleife :P
{ 
    int NochWas = 123;   
    test1(); 
    test2(); 
}

//und noch ein letztes: 4) 
while(i < 200)
{ // kommt zwar nie vor, dass man eine leere Schleife hat, aber ich würds
} // wahrscheinlich so handhaben

    Ausserdem schreib ich Sternchen und Referenzzeichen gleich beim Typ:

    long* Ptr;
const double& ConstRef = Bla;

void Function(int First, double& Second, std::vector<int>& Vector);

    Aber lass dich nicht zu stark beeinflussen; gewöhn dir deinen eigenen Stil an.

    Technohead schrieb:

    Beim Umbrechen ist das auch immer ne Frage der Bildschirmgröße 😃 😉 Ich werde einfach mal sehen, was schöner aussieht und praktikabler ist!! 👍

    Also ich persönlich finde es übersichtlicher, wenn sich die öffnende geschweifte Klammer auf gleicher Höhe wie die schliessende befindet. Ich sehe dann schneller, wo der Block beginnt. Und der benötigte Platz sollte nicht das Problem sein...

    0
  • Administrator

    Über Styles kann man diskutieren bis man stirbt 🙂
    Ich habe persönlich anscheinend einen ähnlichen Style wie der von Nexus. Einzig bei einem leeren while oder for usw. mache ich das etwas anders:

    bool test(int& arg)
{
  // ... mach was und gib true oder false zurück.
}

// ... irgendwo ...

int arg = 0;

while(test(arg));

    Wenn also nix drin ist, dann mache ich gar keine { } Klammern, sondern schreibe einfach gleich ein Semikolon hin.

    Grüssli

    0
  • F

    Dravere schrieb:

    while(test(arg));

    Wenn also nix drin ist, dann mache ich gar keine { } Klammern, sondern schreibe einfach gleich ein Semikolon hin.

    Da mach ich lieber:

    while(test(arg)){ /* really do nothing! */ }

    Ansonsten kommt noch irgend ein Kollege und meint da wäre ein Fehler. 🙂

    0
  • X

    Dravere schrieb:

    int arg = 0;

while(test(arg));

    Wenn also nix drin ist, dann mache ich gar keine { } Klammern, sondern schreibe einfach gleich ein Semikolon hin.

    wobei so ein Semikolon nach ein paar Stunden leicht zu übersehen ist.
    Ich ziehe da eine neue Zeile vor, eventuell mit Kommentar:

    int arg = 0;

while(test(arg))
    ; // do nothing, wait, was auch immer (nicht-)getan werden soll... :)
    0
  • N

    Ja, Semikolon würde ich vielleicht auch machen.

    Aber mal eine Frage: Wann benutzt man eine leere While-Schleife?

    0
  • B
     

    while ( ! the_time_has_come_to_do_something_great() )
    ; // Active waiting
    0
  • N

    Okay. Bei mir wäre es dann eher so, dass ich im Schleifenrumpf noch etwas schreibe, um den Prozessor zu entlasten (Sleep etc.). Aber das kann man ja eigentlich auch in die Funktion packen...

    0
Anmelden zum Antworten