C++ = C++ ?

[ebber]

Hallo

wollte mir eigentlich C++ ein wenig anschauen mit Visual Studio.
Ich habe mir jetzt mehrer Tutorials angesehen aber in allen steht was von

Delphi-Quellcode:

#include <iostream.h>

oder 

cout << "Hello World";

Wenn ich das aber in Visual Studio eintippe will das alles nicht funktionieren.


Ich habe jetzt das gefunden was funktioniert :

Delphi-Quellcode:

#include "iostream" using namespace std;

printf("Hello World");

Was ist jetzt da der unterschied ? Bei beidem steht ja C++ ? :wiejetzt:

MfG

[SirThornberry]

bei dem einen wird die Funktion printf aufgerufen bei der anderen wird mit dem "<<" operator gearbeitet.

[Der_Unwissende]

Zitat:

Zitat von ebber

Delphi-Quellcode:

#include <iostream.h>

oder 

cout << "Hello World";

Wenn ich das aber in Visual Studio eintippe will das alles nicht funktionieren.

Hi,
erstmal kurz zu C-Code, wenn Du das Delphi durch C ersetzt, bekommst Du auch für C das richtige Highlighting :wink:

Was Dein Problem angeht, so hast Du hier bekanntschaft mit dem Namensraum gemacht. Die Frage die sich hier stellt ist, welches VS Du verwendest, ab einer bestimmten Version (kenne ich nicht aus dem Kopf) musst Du die Namensräume immer angeben. Also entweder

Code:

std::cout << "Hello World";

oder eben

Code:

#include "iostream" using namespace std;

// ...
cout << "Hello World"

Beim Include liegt der wichtige Unterschied darin, wo die Datei liegt, die Du einbinden möchtest. Liegt sie im gleichen Verzeichnis wie Dein Programm, verwendet man die Anführungszeichen. Liegt sie im Suchpfad des Compilers, werden die spitzen Klammern verwendet. Da .h kann/muss man (afaik) auch erst ab einer bestimmten Version weglassen. Zudem musst Du aufpassen, ob Du eine managed C++ Version verwendest (also das .net Pendant), da dürfte es einige Änderungen geben, die von den Standard C++ Tutorials abweichen!

Nebenbei um die Frage mal ganz klar zu beantworten C++ != C++
Die sind nicht immer gleich, je nach Compiler wirst Du schnell ein paar (kleine) Unterschiede finden. Das meiste davon betrifft natürlich nicht direkt die Sprache, sondern eher die mitgelieferten/verfügbaren Bibliotheken, die Arbeit mit make-Files usw.

Gruß Der Unwissende

[add]
Ach ja, printf vs. cout, ich glaube printf war die ältere Variante. Jedenfalls steht printf für die Formatierte Ausgabe, hier gibt es ziemlich starke Parallelen zu format von Delphi. Du gibst dabei einen String mit Platzhaltern an und übergibst die Argumente, die an dieser Stelle eingefügt werden sollen:

Code:

printf("Dies ist ein String, in den ein String %s und ein Integer %d eingefügt wird", "BLUBB", 10);
// sollte "Dies ist ein String, in den ein String BLUBB und ein Integer 10 eingefügt wird" ausgeben
// Das gleiche mit cout hätte wohl die Form
cout << "Dies ist ein String, in den ein String" << "BLUBB" << "und ein Integer" << 10 << "eingefügt wird" 
// bei cout bin ich mir nicht ganz sicher, zu lange nicht mit C++ gearbeitet, also lieber nicht glauben!

[/add]

[ebber]

Gut, Danke.

Ich hab das mit VS 2005 gemacht. In den ganzen Tutorials steht aber das oben erwähnte. Gibts vielleicht auch ein Einführungstutorial dafür ?

MfG

[Der_Unwissende]

Zitat:

Zitat von ebber

Ich hab das mit VS 2005 gemacht. In den ganzen Tutorials steht aber das oben erwähnte. Gibts vielleicht auch ein Einführungstutorial dafür ?

Na das Schlimmste hast Du schon geschafft, sehr viel mehr Fallen gibt es auf dem Weg zum "Hello World!" nicht und die meisten Tutorials fangen damit an. Bei den weiteren Beispielen weißt Du ja schon bescheid. Beim Import musst Du im Zweifel immer schauen, ob Du ein .h angeben musst oder nicht. An sich wirst Du hier (wahrscheinlich) etwas in der Form "Header" finden, wenn es um Bibliotheksdateien geht und "Header.h" für die, die Du selbst geschrieben hast, bzw. die unter Header im Projekt angezeigt werden.
Wenn Du das berücksichtigst (ist ja nicht so kompliziert, oder?) dann solltest Du den Rest der Tutorials ganz gut verwenden können. Die meisten fangen eben (wie gesagt) bei "Hello World" an und erklären dann nach und nach die Sprache (Datentypen, Kontrollstrukturen, Fehlerbehandlung, Klassen, ...)

[Torpedo]

cout ist C++, printf funktioniert auch unter C.

Natürlich gibt es viele Arten so ein einfachen Programm wie Hello World zu programmieren.

Hier sind mal die, die ich für am "normalsten" halte:

C++:

Code:

#include <iostream>
using namespace std;

int main() {
   cout<<"Hello World!"<<endl;
   return 0;
}

C:

Code:

#include <stdio.h>

int main() {
   printf("Hello World!");
   return 0;
}

[jmit]

Hallo,

Zitat:

Zitat von ebber

..Gibts vielleicht auch ein Einführungstutorial dafür ?

MfG

Ein spezielles Tutorial für VS2005 kenne ich nicht, aber ich würde auch mit einem allgemeinem C++ Tutorial beginnen.
Zum Suchen einfach einmal Google bemühen.

Gruß Jörg

[Muetze1]

Wieso wird hier mit Kanonen auf Spatzen geschossen? printf() ist zum formatierten Ausgeben von Werten in einem String. Wenn es hier um die reine Stringausgabe geht, dann muss man doch nicht gleich mit dem grossen Holzhammer kommen (wobei hier nichtmal eine Variable ausgegeben wird) sondern nutzt lieber eine einfachere - bessere geeignete Funktion (z.B. puts()).

[hsg]

Zitat:

Zitat von Der_Unwissende

Nebenbei um die Frage mal ganz klar zu beantworten C++ != C++
Die sind nicht immer gleich, je nach Compiler wirst Du schnell ein paar (kleine) Unterschiede finden. Das meiste davon betrifft natürlich nicht direkt die Sprache, sondern eher die mitgelieferten/verfügbaren Bibliotheken, die Arbeit mit make-Files usw.

Gruß Der Unwissende

Die Unterschiede betreffen (leider) auch oft die Sprache selber, so ist z.B. folgender Code unter BCB6 korrekt:

Code:

for (int i=1; i<10; i++) {
....}

for (int i=2; i<100; i++) {
....
}

Dasselbe unter VSC++ funktioniert nicht, da in der 2. for-Schleife das i bereits definiert ist.

So war es zumindest, als ich noch C++ Code schreiben durfte........

[SirThornberry]

sowas macht man ja auch nicht (eine Variable 2 mal declarieren). Selbst wenn der Compiler das unterstützt sollte man sich das gar nicht erst angewöhnen, schließlich entbehrt das jeder logic.

[mkinzler]

Andererseits endet der Scope der Variablen i eigentlich am Ende der Schleife

[hsg]

Zitat:

Zitat von SirThornberry

sowas macht man ja auch nicht (eine Variable 2 mal declarieren). Selbst wenn der Compiler das unterstützt sollte man sich das gar nicht erst angewöhnen, schließlich entbehrt das jeder logic.

wieso entbehrt das jeder Logik?
Ich persönlich finde das eigentlich sogar gut: dadurch das der Typ der Variablen in dem Block steht, ist sofort erkennbar was da passieren soll.

Und wie mkinzler schon gesagt hat: normalerweise ist der Geltungsbereich der Variablen nach der Schleife zu Ende.
Nur dass, da Microsoft mal wieder andere Vorstellung hat.

[DMW]

Zitat:

Zitat von hsg

Und wie mkinzler schon gesagt hat: normalerweise ist der Geltungsbereich der Variablen nach der Schleife zu Ende.

So sagt der Standard. Und auf den kommt es an.
Ebendieser ist übrigens auch daran schuld, daß z.B. #include <iostream.h> nicht mehr funktioniert. Es heißt <iostream> !

Zitat:

Zitat von hsg

Nur dass, da Microsoft mal wieder andere Vorstellung hat.

IIRC war das beim MSVC 6.0 (1998!) so. Die aktuellen Microsoft-Compiler erfüllen den C++-Standard ziemlich gut.

@Muetze1: Sogar Kernighan und Ritchie benutzen printf() und nicht puts() für ihr Hello World. Vermutlich zugunsten der Konsistenz ;)

Zitat:

Zitat von SirThornberry

sowas macht man ja auch nicht (eine Variable 2 mal declarieren).

Genau. Und Variablen definiert man am Anfang des Blockes ;)
Das ist C++, nicht Delphi oder C. In C++ findet, da u.a. im Gegensatz zu den anderen gängigen objektorientierten Sprachen wie Delphi Stackobjekte eine große Rolle spielen, zumeist RAII (Resource Acquisition Is Initialisation) Anwendung.

[hsg]

Zitat:

Zitat von DMW

Zitat:

Zitat von hsg

Nur dass, da Microsoft mal wieder andere Vorstellung hat.

IIRC war das beim MSVC 6.0 (1998!) so. Die aktuellen Microsoft-Compiler erfüllen den C++-Standard ziemlich gut.

Dazu kann ich nichts weiter sagen, ich habe die aktuellen MSVC-Compiler nicht getestet. Wenn man einen Kollegen ärgern wollte, hat man im Projekt beim Cbuilder 6 die MS-Kompatibilität eingeschaltet und der Kollege wurde auf einmal von tausenden Fehlern überhäuft :-D

[delphilover]

häääääääääääääääääääääääääääääääääääääää

:shock:
:kotz:

[angos]

Hallo delphilover,

bitte stelle doch konkrete Fragen, was du an den Posts über dir nicht verstehst. Ein solches gespamme wird in Foren allgemein nicht gern gesehen.

[ebber]

Falls ich noch ne kurze Frage stellen darf:

Wenn ich jetzt ein neues win32 Project mache erstellt es ja automatisch eine Form die aber irgendwie nicht richtig da ist ?
Ich kann dann noch eine Neue hinzufügen und mit der geht alles wunderbar wie in Delphi. Mache ich was falsch? oder wo kann ich umstellen welches die Form ist die beim Programmstart angezeigt wird.

MfG

[WS1976]

Hallo,

unter Visual C++ 2005 gibt's keine Headerdatei iostream.h mehr!
Wie man alternativ cout oder cin nutzt weiss ich auch nicht.

Grüsse
Rainer

[Matze]

Zitat:

Zitat von hsg

Zitat:

Zitat von DMW

Zitat:

Zitat von hsg

Nur dass, da Microsoft mal wieder andere Vorstellung hat.

IIRC war das beim MSVC 6.0 (1998!) so. Die aktuellen Microsoft-Compiler erfüllen den C++-Standard ziemlich gut.

Dazu kann ich nichts weiter sagen, ich habe die aktuellen MSVC-Compiler nicht getestet.

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

[Xong]

Zitat:

Zitat von SirThornberry

sowas macht man ja auch nicht (eine Variable 2 mal declarieren). Selbst wenn der Compiler das unterstützt sollte man sich das gar nicht erst angewöhnen, schließlich entbehrt das jeder logic.

Du bist das aus Delphi nur nicht gewöhnt. Ich vermisse es schmerzlich.

Code:

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

Dieser Code bewirkt, dass ein 4 Byte großer Speicherplatz reserviert und mit 0 initialisiert wird. Dann wird i schrittweise bis auf 10 erhöht. Schließlich wird der Speicherplatz wieder freigegeben.

In C++ ist sogar folgendes möglich:

Code:

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

[Matze]

Zitat:

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:

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:

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 :P
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:

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 :zwinker:
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:

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 :zwinker:

Asche auf mein Haupt! :wall:

[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:

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:

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:

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:

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.