C++ = C++ ?

[Matze]

Zitat von Xong:

In C++ ist sogar folgendes möglich:

Code:

for(int i = 0; i < 10; i++) {
  for(int i = 0; i < 10; i++) {
    // Mach was!
  }
}

Tatsache, das wusste ich auch noch nicht! Doch das nutze ich persönlich nicht, da innerhalb der 2. Schleife beide Laufvariablen existieren, mal abgesehen von der Übersicht, die nicht mehr gegeben ist.

[Xong]

Zitat von Matze:

Tatsache, das wusste ich auch noch nicht! Doch das nutze ich persönlich nicht, da innerhalb der 2. Schleife beide Laufvariablen existieren, mal abgesehen von der Übersicht, die nicht mehr gegeben ist.

Da stimme ich dir zu. Außerdem hat man (afair) keine Möglichkeit aus der inneren Schleife heraus auf das äußere i zuzugreifen.
Zumal es auch nicht sehr günstig ist, eine Variable in einer Schleife zu deklarieren.
Besser wäre deshalb:

Code:

for(int i,k = 0; i < 10; i++) {
  for(k = 0; k < 10; k++) {
    // Mach was...
  }
}

[OregonGhost]

Zitat von Xong:

In C++ ist sogar folgendes möglich:

Code:

for(int i = 0; i < 10; i++) {
  for(int i = 0; i < 10; i++) {
    // Mach was!
  }
}

Wer in meinem Team sowas schreibt, kriegt ne Standpauke zu hören
Mal abgesehen davon, dass i ein eher unglücklicher Name für eine Schleifenvariable ist (spätestens bei verschachtelten Schleifen) gehört so eine Fehlerquelle definitiv nicht in Code gegossen. Aber die Sprache erlaubt sie, ja, was in so einem offensichtlichen Fall eher schlecht ist, aber an vielen anderen Stellen hilfreich, denn davon abgesehen ist es in C++ gängig, Variablen erst zu deklarieren (und damit gegebenenfalls zu initialisieren), wenn sie wirklich benötigt werden. Die for-Schleifenvariable ist ein schönes Beispiel dafür. Was juckt mich außerhalb der Schleife das i? Die meisten Sprachen, die die Deklaration außerhalb fordern, garantieren trotzdem nicht einen bestimmten Wert für die Variable, wenn die Schleife verlassen wird.

@Rainer:
Wie DMW schon sagte: es gibt im C++-Standard überhaupt keinen Header <iostream.h>. Der Name des Headers ist standardkonform <iostream>. Ebenso, wie z.B. die stdio von C in C++ nicht als <stdio.h>, sondern als <cstdio> eingebunden wird. Also macht VC++ das richtig. <iostream.h> gab es nur in der Übergangszeit, in der der Standard noch nicht so weit war. Zu dem Zeitpunkt war der Unterschied (laut Standard), dass die Standardbibliothek bei <iostream.h> global ist, bei <iostream> hingegen im Namespace std liegt.

[JasonDX]

Zitat von Xong:

Zumal es auch nicht sehr günstig ist, eine Variable in einer Schleife zu deklarieren.
Besser wäre deshalb:

Code:

for(int i,k = 0; i < 10; i++) {
  for(k = 0; k < 10; k++) {
    // Mach was...
  }
}

Nein, die Sichtbarkeit einer Variable sollte so restriktiv wie möglich sein. Außerhalb der inneren for-Schleife ist k nicht notwendig, und hat dort somit nur sehr wenig verloren. Zudem passieren dann auch nicht solche Dinge, dass man vergisst, i zu initialisieren
Aber 2 gleiche Variablennamen in einer Funktion sind schon unter aller Sau. Zwar hat der innerste Block immer Priorität, aber eben wie du schon sagtest, Zugriff auf die Variable des äußeren Blocks ist dann unmöglich. Zudem ist es extremst unleserlich...

Zitat:

Nur kurz dazu: Im VS 2005 geht das glücklicherweise problemlos, im Schleifenkopf die gleichen Variablen zu deklarieren/definieren.
Ich mache das immer so.

Zumindest bei C++-Datein gehts. Wenn der Compiler auf C-Code beschränkt wird (einfach durch .c statt .cpp als Dateiendung) können Variablen nur zu Funktionsbeginn deklariert werden

greetz
Mike

[Xong]

Zitat von JasonDX:

Nein, die Sichtbarkeit einer Variable sollte so restriktiv wie möglich sein. Außerhalb der inneren for-Schleife ist k nicht notwendig, und hat dort somit nur sehr wenig verloren. Zudem passieren dann auch nicht solche Dinge, dass man vergisst, i zu initialisieren

Asche auf mein Haupt!

[Muetze1]

Wenn ihr schon C++ schreibt, dann würde ich nicht die Variablen i anlegen lassen (Constructor) um dann wieder eine Wertzuweisung zu machen. Von daher, wenn es denn C++ sein soll, würde ich immer folgendes vorziehen:

Code:

(int i(0); i < 10; i++);

[OregonGhost]

Zitat von Muetze1:

Wenn ihr schon C++ schreibt, dann würde ich nicht die Variablen i anlegen lassen (Constructor) um dann wieder eine Wertzuweisung zu machen. Von daher, wenn es denn C++ sein soll, würde ich immer folgendes vorziehen:

Code:

(int i(0); i < 10; i++);

Du irrst.

Code:

int i = 0;

ist identisch mit

Code:

int i(0);

.
Welche Schreibweise besser lesbar ist, ist vermutlich offensichtlich. Das erste ist zudem keine Zuweisung, sondern eine Initialisierung, das ist in C++ ein erheblicher Unterschied.

[Muetze1]

Zitat von OregonGhost:

Du irrst.

Code:

int i = 0;

ist identisch mit

Code:

int i(0);

.
Welche Schreibweise besser lesbar ist, ist vermutlich offensichtlich. Das erste ist zudem keine Zuweisung, sondern eine Initialisierung, das ist in C++ ein erheblicher Unterschied.

Meines Wissens würde ein

Code:

int i = 0;

zwei mal einen Constructor von int aufrufen: einmal den von i und einmal ein temporäres Objekt mit 0. Danach weist er das temporäre Objekt i zu und gibt das temporäre Objekt frei.

Mit

Code:

int i(0);

aber wird direkt der Constructor von i aufgerufen i und somit gibt es nur einen Constructor Aufruf und kein temporäres Objekt.

/EDIT: Die Frage ist eher: Wie gut ist dein C++ Compiler, als dass er im ersten Falle das temporäre Objekt wegoptimiert. Vom reinen Sprachsatz/-standard her, läuft es im ersten Falle wie beschrieben ab.

[OregonGhost]

Nein, das stimmt nicht. Und selbst wenn der Standard es vorschreiben würde, würde jeder Compiler es wegoptimieren.

Zitat von IBM:

You explicitly initialize a class object when you create that object. There are two ways to initialize a class object:

* Using a parenthesized expression list. The compiler calls the constructor of the class using this list as the constructor's argument list.
* Using a single initialization value and the = operator. Because this type of expression is an initialization, not an assignment, the assignment operator function, if one exists, is not called. The type of the single argument must match the type of the first argument to the constructor. If the constructor has remaining arguments, these arguments must have default values.

Ich bleibe bedauerlicherweise ein Zitat aus dem ISO-Standard schuldig. Den kann man einfach nicht lesen. Jedenfalls sagt der Sprachstandard das gleiche aus, nur in etwa zwanzigmal so viel Zeilen und auf eine Art und Weise, die man sowieso nicht versteht
Aber es sagt genau das:

Code:

int i = 0;

ist keine Zuweisung, sondern eine Initialisierung und damit erfolgt genau ein Konstruktoraufruf.

Edit:
Das Zitat oben stammt aus der Dokumentation zu einem der IBM-C++-Compiler. Ich kann dir aber versichern, dass auch z.B. Visual C++ und der GCC sich genau so verhalten, und dass sie es nicht tun, weil sie einfach nur gut optimieren.

[DMW]

Zitat von Muetze1:

Meines Wissens würde ein

Code:

int i = 0;

zwei mal einen Constructor von int aufrufen: einmal den von i und einmal ein temporäres Objekt mit 0. Danach weist er das temporäre Objekt i zu und gibt das temporäre Objekt frei.

Das ganze hat noch einen Haken: int hat, wie alle POD-Typen, keinen Konstruktor

Du kannst zwar um der Konsistenz willen Konstruktoren (mittels Placement New) und Destruktoren von POD-Typen aufrufen, jedoch sind solche Aufrufe wirkungslos.