template <class T> int*
Foo_Bar::Get_My_Line(int&   a,
                     int&   b,
                     int*   arr,
                     double c,
                     int    line)
{
    int    az    = 0,
           bz    = 1,
           *arrb = NULL,
           cz    = 3;

    double u     = 3.3,
           g     = -1.9;

    arrb = Fill_Array(az, bz);

    for (int i = 0; i < 100; i++)
    {
        arrb[i] = -2;
    }

    return arrb;
}

Also meine persönliche Meinung: Ich finde die Parameter-Deklarationen untereinander nicht gut. Solche eingerückten Deklarationen mache ich eigentlich nur in Klassen, aber dort ist auch genügend Abstand vorhanden. Wenn nämlich ein komplexerer Typ dazukommt, kannst du neu einrücken, sehr konsistent bist du damit nicht. Auch der Rückgabetyp auf einer separaten Linie gefällt mir nicht - ich finde es übersichtlicher, diesen in gleicher Zeile mit dem Funktionsnamen zu schreiben. Das template ist allerdings okay eine Zeile vorher.

Innerhalb der Funktion verhält sich das Ganze ähnlich: Ich habe eigentlich nie Mehrfachdeklarationen. Bei mir kommt es auch nicht sehr oft vor, dass ich mehrere Variablen gleichen Typs nacheinander deklariere - und wenn doch, gebe ich den Typen jedes Mal an. Der Rest (Block-Einrückungen, Abstände) sieht für mich gut aus, das mache ich ähnlich.

template <class T>
int* Foo_Bar::Get_My_Line(int& a, int& b, int* arr,
						  double c, int line)
{
	int az = 0,
        bz = 1,
        *arrb = NULL,
        cz = 3;

    double u = 3.3, g = -1.9;
    arrb = Fill_Array(az, bz);

    for(int i = 0; i < 100; i++) {
        arrb[i] = -2;
    }

    return arrb;
}

template <class T>
int* Foo_Bar::Get_My_Line(int& a, int& b, int* arr, double c, int line)
{
    int az = 0, bz = 1, cz = 3, *arrb = 0;
    double u = 3.3, g = -1.9;

    arrb = Fill_Array(az, bz);

    for(int i = 0; i < 100; i++)
        arrb[i] = -2;

    return arrb;
}

beschissen

Hallo, ich würde gerne eine Meinung wissen wie ihr einen solchen code-stil findet den ich neulich gesehen habe

das akkurate ausrichten von bezeichnern wäre mir viel zu anstrengend zu warten. und das geht doch sowieso spätestens beim zweiten programmierer kaputt.
underscores UND camelcase finde ich auch sehr gewöhnungsbedürftig. entweder DasEine oder das_andere, aber nicht Beides_Gleichzeitig.
die bezeichner sind kryptisch, und die magischen zahlen im code sind auch unschön.
aber sonst ist alles super

sdfsdf schrieb:

Man liest halt eher von oben nach unten anstatt Zeilenweise.

wo ist der unterschied?

template <class T>
int* Foo_Bar::Get_My_Line(int& a, int& b, int* arr,
                          double c, int line)
{
    double u = 3.3;
    double g = -1.9;
    int cz = 3;

    int az = 0;
    int bz = 1;
    int *arrb = Fill_Array(az, bz);
    for (int i = 0; i < 100; i++)
    {
        arrb[i] = -2;
    }
    return arrb;
}

aber das läßt sich an diesem beispiel kaum zeigen. sowas wie "variablen so lokal wie möglich machen" und "eine funktion - ein zweck" ziehen allerhand anderes dann nach sich, zum beispiel nicht mehrere variablen in einer deklararion und arrb nicht mal auf vorrat mit NULL initialisieren.

Mit den Camelcases und underscores kann ich bis heute nicht meine linie finden.

Mir ist klar dass solche "wie sieht euer code aus"-fragen für die katz sind - aber dennoch beschäftigt mich auch so etwas bis heute unentwegt...

Ich versuche code immer möglichst untereinander zu schreiben weil das meiner Ansicht nach übersichtlicher ist.

Das ist wie du siehst Geschmackssache, ich persönlich schreibe die Deklaration von Parametern auch untereinander (wenn auch im anderen Stil):

template <class T>
int* FooBar::GetMyLine(
    int& a,
    int& b,
    int* arr,
    double c,
    int line)
...
// Einrückungen ansonsten in etwa wie bei volkard

Dazu muss man aber auch sagen, das ich in der Regel mit wesentlich längeren Datentypen und Bezeichnern arbeite (z.B. "std::vector<int> ressourceIds") und gleichzeitig versuche Zeilen nicht länger als 82 Zeichen (Wegen Ausdrucken - was ich selten mache, dennoch habe ich es mir so Angewöhnt) zu machen.

Neuling1 schrieb:

Wenn man z.B. in einer signatur mehr als 5 parameter hat...

In der Praxis ist es bei mir äußerst selten wenn mehr als 3-4 Parameter verwendet werden (Ausnahme ggf. bei Konstruktoren).

Die Angewohnheit pro Variablendeklaration eine Zeile zu verwenden und niemals mehr als eine Variable auf einmal zu deklarieren wirst du aber bei vielen sehen. Zudem ist es normal, das man Variablen erst bei ihrer ersten Verwendung deklariert.

Neuling1 schrieb:

Mit den Camelcases und underscores kann ich bis heute nicht meine linie finden.

Unabhängig davon welchen Stil du wählst: sei konsequent!

cu André

Hallo, ich würde gerne eine Meinung wissen wie ihr einen solchen code-stil findet den ich neulich gesehen habe - der code macht nix:

...

Erinnert mich an n scherzposting das ich neulich irgendwo gesehen hab:

Es                              wäre
lustig                          wenn
du                             sehen
könntest                         wie
deine                          Augen
behindert                        von
links                           nach
rechts                        hüpfen

Mal ehrlich, findest du sowas leicht lesbar? Ich finds grauenvoll.

volkard schrieb:

meiner ist eher so

template <class T>
int* Foo_Bar::Get_My_Line(int& a, int& b, int* arr,
                          double c, int line)
{
    double u = 3.3;
    double g = -1.9;
    int cz = 3;

    int az = 0;
    int bz = 1;
    int *arrb = Fill_Array(az, bz);
    for (int i = 0; i < 100; i++)
    {
        arrb[i] = -2;
    }
    return arrb;
}

Mal abgesehn davon dass ich zu vermeiden versuche Funktionen mit zig Parametern, zu Anfang definierten und unbenutztn Variablen zu schreiben, siehts bei mir ähnlich aus

meiner ist eher so

template <class T>
int* Foo_Bar::Get_My_Line(int& a, int& b, int* arr,
                          double c, int line)
{
    double u = 3.3;
    double g = -1.9;
    int cz = 3;

    int az = 0;
    int bz = 1;
    int *arrb = Fill_Array(az, bz);
    for (int i = 0; i < 100; i++)
    {
        arrb[i] = -2;
    }
    return arrb;
}

Genau den gleichen Stil hab ich auch. Ich finde es persöhnlich nicht gut, wenn mann mehrere Variablen in einer Zeile deklariert/definiert. Außerdem, eine Variable zu deklarieren und eine Zeile darunter sie definieren, finde ich schwachsinnig.

pumuckl schrieb:

Mal abgesehn davon dass ich zu vermeiden versuche Funktionen mit zig Parametern zu schreiben

Die Frage ist auch, ob es Sinn ergibt.

Wie gesagt, mein Stil is eig. wie volkard's, nur das ich noch versuche, wenn ich überhaupt soviele Parameter habe, sie in eine Zeile zu schreiben.

mfg

Oder schreibt anständige Programme! :p
Ersteres ist wohl einfacher ...

Wie gesagt, mein Stil is eig. wie volkard's, nur das ich noch versuche, wenn ich überhaupt soviele Parameter habe, sie in eine Zeile zu schreiben.

ups, ich auch. hab hier nicht drauf geachtet. aber bei über 80 zeichen breite breche ich dann doch mal um.

0         1         2         3         4         5         6         7
01234567890123456789012345678901234567890123456789012345678901234567890123456789
int* Foo_Bar::Get_My_Line(int& a,int& b,int* arr,double c,int line)

da war noch massig platz.

Da ich noch nicht viel in der Industrie mit programmierung zu tun hatte frage ich mich eben wie es sauber wäre bzw. was die Leute gerne sehen an Stil.

Zudem ist es normal, das man Variablen erst bei ihrer ersten Verwendung deklariert.

hier würde ich gerne nochmal nachfragen:

Also variablen erst deklarieren wenn sie unmittelbar gebraucht werden? So in etwa (sinnloses beispiel aber nur als frage)?

template <class T>
int* Foo_Bar::Get_My_Line(int& a, int& b, int* arr,
                          double c, int line)
{
    double u = 3.3;

    int *arrb = Fill_Array(az, bz);
    for (int i = 0; i < 100; i++)
    {
        arrb[i] = -2;
    }

    int a = 8;
    for (int i = 0; i < a; i++)
          arrb[i] = -1;

    double c = 9.9;
    arrb[0] = c;

    return arrb;
}

int* FooBar::get_my_line(int number)

Ja so kommt es eig. öfters bei mir vor.

Eine Variable erst zu benutzen wenn du sie brauchst, kannst du ruhig machen. Meistens mache ich es auch so.

@volkard und rest: Also ihr macht auch Get_My_Line() und nicht getMyLine() oder get_my_line() ?

die letzten beiden Varianten hab ich schon gesehen, die erste nicht. Also entweder CamelCase oder unter_striche

Neuling1 schrieb:

Also variablen erst deklarieren wenn sie unmittelbar gebraucht werden?

Ja. Zumindest nahe der Stelle wo sie deklariert werden. Dann muss man im Zweifel nicht erst hochscrollen um zu schauen von welchem Typ Variable xy nochmal war, und man hat nicht irgendwelche verwirrenden Deklarationen im Text stehen die an der Stelle noch garkeinen Sinn ergeben.

@volkard und rest: Also ihr macht auch Get_My_Line() und nicht getMyLine() oder get_my_line() ?
Da ich noch nicht viel in der Industrie mit programmierung zu tun hatte frage ich mich eben wie es sauber wäre bzw. was die Leute gerne sehen an Stil.

ich nehmen nur KlassenName::funktionsName. aber richtung microsoft wirste oft KlassenName::FunktionsName sehen und in nder anderen reichtung gehts bis klassen_name::funktions_name
und da gibt es kein besser oder schlechter, man macht einfach das, was im unternehmen üblich ist. kannst ja schlecht die bestehenden bibliotheken so verfummeln, daß der anwender dann

void FooBar::GetMyLine(){
  foo_bar_base::get_my_line();
  if(Error) throw Foo_Bar_Exception(Error);
}

schreiben muß.

Neuling1 schrieb:

Also variablen erst deklarieren wenn sie unmittelbar gebraucht werden?

Ja. Zumindest nahe der Stelle wo sie deklariert werden. Dann muss man im Zweifel nicht erst hochscrollen um zu schauen von welchem Typ Variable xy nochmal war, und man hat nicht irgendwelche verwirrenden Deklarationen im Text stehen die an der Stelle noch garkeinen Sinn ergeben.

Eine Funktion/Methode sollte auch nie laenger sein als eine Bildschirmseite (vielleicht noch zwei).

Eine Funktion/Methode sollte auch nie laenger sein als eine Bildschirmseite (vielleicht noch zwei).

Das auch. wobei eine Bildschirmseite schon sehr viel ist, 10-15 Zeilen sind meist schon mehr als genug. Trotzdem gehören Deklarationen von Variablen dort hin wo sie verwendet werden, wo sie sinnvoll initialisiert werden können (meist erst unimttelbar vor der verwendung), und wo sie nicht aus dem Kontext gerissen werden (und der Kontext beginnt dort wo sie verwendet werden).