C++ Struktur in Schleife inizialisieren unartig?

[X. H. (shadow0815)]

Hi!

Man kann ja Stukturen mit

STR str={3,5,"lalala"};

nur inizialisieren bei der Deklaration, und nicht später:

str={3,5,"lalala"}; //Error! - Nur bei Deklaration erlaubt!

In C++ kann ich nun aber folgendes machen:

#include <iostream>
char ajdlksfjkspause;
#define Pause() ajdlksfjkspause=getc(stdin); 
using namespace std;

int main(int argc, char *argv[])
{
    typedef struct {int a;int b;}VAR;
    int thea=2;
    
    for(int theb=0;theb<100;theb++)
    {
       VAR var={thea,theb}; // <--- is dies ungezogen?
       cout<<"---> a: "<<var.a<<" b: "<<var.b<<endl;
    }
 Pause();
}

Und es funktioniert. Beim ersten Durchlauf der Schleife wird das var
deklariert und mit {thea,theb} inizialisiert.
Beim Nächsten Durchlauf auch wieder, obwohl es die Variable ja schon 
gibt. Comiler meint wohl: "Egal, steht der Typ VAR vor, darf also immer 
wieder neu
inizialisiert werden...?!"

Gehört sowas zu unsauberem Programmierstil?
Es geht so schön schnell, wenn man mal z.B. ein Rechteck definieren 
will:

bsp.:

int a=50;
int b=100;
SDL_Rect rect={50,50,a,b};

[Karl H. (kbuchegg)]

X. H. wrote:
> Hi!
>
> Man kann ja Stukturen mit
>

STR str={3,5,"lalala"};

> nur inizialisieren bei der Deklaration, und nicht später:
>

Richtig

>

str={3,5,"lalala"}; //Error! - Nur bei Deklaration erlaubt!

Auch richtig. Das ist keine Initialisierung sondern eine
Zuweisung.

>
> In C++ kann ich nun aber folgendes machen:
>

> #include <iostream>
> char ajdlksfjkspause;
> #define Pause() ajdlksfjkspause=getc(stdin);
> using namespace std;
> 
> int main(int argc, char *argv[])
> {
>     typedef struct {int a;int b;}VAR;
>     int thea=2;
> 
>     for(int theb=0;theb<100;theb++)
>     {
>        VAR var={thea,theb}; // <--- is dies ungezogen?
>        cout<<"---> a: "<<var.a<<" b: "<<var.b<<endl;
>     }
>  Pause();
> }
>

>
> Und es funktioniert. Beim ersten Durchlauf der Schleife wird das var
> deklariert und mit {thea,theb} inizialisiert.

Bei jedem Durchlauf wird eine Variable var erzeugt und
initialisiert. Sobald das } erreicht wird, ist die
Lebenszeit für var abgelaufen und es wird zerstört.
Wird der Schleifenkörper erneut betreten, so wird wieder
eine naue Variable var erzeugt.

> Beim Nächsten Durchlauf auch wieder, obwohl es die Variable ja schon
> gibt.
>
> Comiler: "Egal, steht der Typ VAR vor, darf also immer wieder neu
> inizialisiert werden...?"

Das ist, na ja, etwas fremdartig formuliert.
Du solltest dir nochmal die sog. 'Scope-Regeln' für Variablen
zu Gemüte führen.
Kurz gesagt: Bei der Deklaration einer Variablen wird sie
erzeugt (und auch möglicheriweise initialisiert). Die Variable
stirbt, wenn der Block in dem sie deklariert wurde, zu Ende ist
(wenn also das Block abschliessende } erreicht wird).

>
> Gehört sowas zu unsauberem Programmierstil?

Nein. wieso sollte es?
Wenn du in jedem Schleifendurchlauf eine neue Variable haben
willst, dann ist das so.

> Es geht so schön schnell, wenn man mal z.B. ein Rechteck definieren
> will:
>
> bsp.:
>

> int a=50;
> int b=100;
> SDL_Rect rect={50,50,a,b};
>

Spricht nichts dagegen.
Ganz im Gegenteil. Man versucht Variablen erst dann zu
deklarieren (und damit auch zu initialisieren) wenn sie
tatsächlich gebraucht werden.

[X. H. (shadow0815)]

Danke für die Aufklärung.
Hab was ähnliches auch noch in C geschrieben und gemerkt dass es da ja 
auch erlaubt ist :)

Bin nicht drauf gekommen, dass eine Whileschleife mit {}
wieder ein Block für sich ist, weil das ja eben die Eigenschaft der 
Block-Klammer ist und darin dann wieder lokale variablen vorhanden sein 
können, die eben nur einen Schleifenzyklus überleben.