C++ Visual C++ Express alle Programme schliessen.

[SpieleHacksInfo]

Hey ich habe ein merkwürdiges Problem. Alle Programme, die ich als Konsolenanwendung schreibe schliessen. Habe den Pc letztens zurück gesetzt.

Programm:

#include <iostream>                                    

int main(){                                            
    std::cout << "Hallo, du schöne Welt!" << std::endl; 

    return 0;                                           
}

Konsole:

"est.exe": "C:\Users\SHI\Documents\Visual Studio 2010\Projects\est\Release\est.exe" geladen, Symbole wurden geladen.
"est.exe": "C:\Windows\SysWOW64\ntdll.dll" geladen, Symbole geladen (ohne Quellinformationen).
"est.exe": "C:\Windows\SysWOW64\kernel32.dll" geladen, Symbole geladen (ohne Quellinformationen).
"est.exe": "C:\Windows\SysWOW64\KernelBase.dll" geladen, Symbole geladen (ohne Quellinformationen).
"est.exe": "C:\Windows\SysWOW64\msvcp100.dll" geladen, Symbole geladen (ohne Quellinformationen).
"est.exe": "C:\Windows\SysWOW64\msvcr100.dll" geladen, Symbole geladen (ohne Quellinformationen).
Das Programm "[7160] est.exe: Systemeigen" wurde mit Code 0 (0x0) beendet.

getchar und systempause helfen nicht!

[Dr. Coxxy]

das System("pause") bzw. das getchar müssen vor das return 0;

[SpieleHacksInfo]

Hatte ich vorhin versucht. Jetzt geht es auf einmal O.o . Ok thx.

[Da_Killa]

#include <iostream>

using namespace std;

int main()
{

   cout << "Hallo Welt" << endl;

   getchar();
   return 0;

}

Durch das

 using namespace std;

sparst du dir immer das std::

[MrSm!th]

Originally Posted by Da_Killa

#include <iostream>

using namespace std;

int main()
{

   cout << "Hallo Welt" << endl;

   getchar();
   return 0;

}

Durch das

 using namespace std;

sparst du dir immer das std::

Verbreite bitte woanders schlechte Tipps.

[Da_Killa]

Würde der allwissende Herr vieleicht auch erklären warum das ein schlechter Tipp ist ?
Ich hab das immer so "gelernt", wenn ich da was falsch verstanden habe tut es mir leid dies gepostet zu haben.
Eine Erklärung wäre nett und hilfreich

// gelernt in Anführungszeichen weil ich nie richtig Programmieren gelernt habe sondern nur ein paar basics im Internet aufgegriffen habe und helfen wollte

mfg Da_Killa

[TIMΣ™]

Originally Posted by Da_Killa

#include <iostream>

using namespace std;

int main()
{

   cout << "Hallo Welt" << endl;

   getchar();
   return 0;

}

Durch das

 using namespace std;

sparst du dir immer das std::

Naja wenn du schon das std:: nicht rausschreiben willst, dann aber bitte anders.

using std::cout;
...

Musst nur jenachdem sagen für welche Funktion das std nicht geschrieben werden muss. In deinem Beispiel ist es eben std::cout.

[Da_Killa]

Originally Posted by TIMΣ™

Naja wenn du schon das std:: nicht rausschreiben willst, dann aber bitte anders.

using std::cout;
...

Musst nur jenachdem sagen für welche Funktion das std nicht geschrieben werden muss. In deinem Beispiel ist es eben std::cout.

Danke war sehr hilfreich

d.h. also wenn ich using namespace std; schreibe dann setzt er das automatisch vor jede funktion, auch da wo es garnicht hingehört ?

[MrSm!th]

Deshalb macht man das nicht.

[Tasiro]

Originally Posted by Da_Killa

d.h. also wenn ich using namespace std; schreibe dann setzt er das automatisch vor jede funktion, auch da wo es garnicht hingehört ?

Nein, das stimmt auch nicht wirklich.
Ich habe mal ein kleines Beispiel zusammengestellt:

 Spoiler

#include <iostream>

namespace n {
	struct s {};

	void f (s) { std::cout << "n::foo(n::s)\n"; }

	void f (const s *) { std::cout << "n::foo(const n::s *)\n"; }
}

void f (int) { std::cout << "foo(int)\n"; }

template <typename T>
void f (T) { std::cout << "foo(T)\n"; }

template <typename T>
void f (T *) { std::cout << "foo(T*)\n"; }

void f (const n::s *) { std::cout << "foo(const n::s *)\n"; }

int main () {
	using n::s;
	s obj;

	f (1);			// f(int)
	// Funktionen werden Templatefunktionen vorgezogen.

	f <int> (1);	// f(T) mit T=int
	// Es kann nur eine Templatefunktion sein.

	f (1.f);		// f(T) mit T=float
	// Templatefunktionen werden Funktionen vorgezogen,
	// wo eine Konvertierung notwendig ist, und sei es ein fehlendes const.

	f (& obj);		// f(T*) mit T=n::s
	// Es kommen f<n*>(n*) und f<n>(n*) in die nähere Auwahl.
	// Da letztere Templatefunktion spezieller ist, wird sie gewählt.

	f (obj);		// n::f(n::s)
	// "Argument dependent name lookup" (ADL): Es werden alle Funktionen in
	// den Namensräumen aller Argumente ebenfalls in Betracht gezogen.
	// Hier ist das der Namensraum "n".

	//f (const_cast <const s *> (& obj));		// Fehler
	// Es kommen "f(const s*)" und "n::f(const s*)" in Frage.
	// Keine wird vorgezogen, also kommt es zu einem Fehler.

	std::cin.get ();
}

Es gibt dann noch einige weitere Möglichkeiten (z. B. das "Verdecken" von Namen), aber das würde hier zu weit führen.

[TIMΣ™]

Originally Posted by Da_Killa

Danke war sehr hilfreich

d.h. also wenn ich using namespace std; schreibe dann setzt er das automatisch vor jede funktion, auch da wo es garnicht hingehört ?

Ne, eigentlich nur dahin, wo es auch hingehört.

Bsp:

[I](std::)[/I][B]cout;[/B]
[I](std::)[/I][B]endl;[/B]
[I](std::)[/I][B]cin;[/B]
[I](std::)[/I][B]string;[/B]
...

Da wird es dann automatisch erkannt, wenn du das globale namespace verwendest.

[Tasiro]

Habe ich doch tatsächlich vergessen, die Wirkung zu beschreiben...

Eine using-Direktive führt alle Bezeichner eines Namensraumes in den aktuellen Gültigkeitsbereich ein. Dadurch kann es zu Konflikten und unerwarteten Ergebnissen kommen, siehe mein Beispiel oben, vor allem, wenn unbekannt ist, was alles in dem Namensraum ist.
Eine using-Deklaration führt genau einen Bezeichner in den aktuellen Gültigkeitsbereich ein. Prinzipiell besteht das gleiche Problem, nur weiß man ja, welche Bezeichner so eingeführt wurden.