global, lokal

hallo leute
ich frage mich ob mein compiler spinnt.

#include<iostream>
using namespace std;

  int a = 10, b = 20; //Definiere Global
  int main()
  {
  cout << a << endl << b << endl; //Anzeige Global
  int a = 1, b = 2; //Definiere Lokal
  cout << a << endl << b << endl; //Anzeige Lokal
  // Neuer Block
  {
  // int a, b;
  a = 10000;
  b = 20000;
  cout << a << endl << b << endl; //Anzeige Neuer Block
  } 
  //Ab hier wieder Lokal
  cout << a << endl << b << endl;
  return 0; 
  }

die ausgabe davon ist folgende.
10
20
1
2
10000
20000
10000
20000
das verstehe ich nicht weil der sollte doch
10
20
1
2
10000
20000
10
20
anzeigen, also Global, Lokal, Neuer Block und wieder Lokal
wenn ich aber im Neuer Block a und b deklariere dann macht er das auch, wenn ich a und b nicht deklariere dann zeigt er den wert aus dem letzten block an!

ist das normal oder spinnt mein compiler.
dev-cc 4.9.8.5 mit mingw-compiler.
danke , bye

dEUs

Der "letzte Block", wie du ihn nennst, ist kein vorhergehender, sondern dein "neuer Block" ist in diesen eingebettet! Das heisst, dieser Block kennt deine Variablen, die du im übergeordneten Block deklariert und definiert hast natürlich auch!

ja da habe ich mich falsch ausgedrückt!
im "eingebetteten block" werden den variablen a + b werte zugewiesen, ist es normal das die werte jetzt auch aus diesem "eingebetteten block" heraus angenommen werden.
ich meine normal müßte die letzte cout-ausgabe doch wieder die ausgabe vom äußeren block haben. wenn ich aber im "eingebetteten block" den datentyp deklariere dann macht er das ja auch.
also anders gefragt, muß man den datentyp in einem neuen eingebetteten block deklarieren?
irgendwie verstehe ich die logik jetzt nicht mehr .... datentyp angeben also bleiben die werte "im (eingebetteten) block", wenn nicht angeben dann werden die werte auch außerhalb des "eingebetteten block"s übernommen?

Hier mal der Unterschied den ich meine.

#include<iostream> 
using namespace std; 

  int a = 10, b = 20; //Definiere Global 
  int main() 
  { 
  cout << a << endl << b << endl; //Anzeige Global 
  int a = 1, b = 2; //Definiere Lokal 
  cout << a << endl << b << endl; //Anzeige Lokal 
  // Neuer Block 
  { 
  // int a, b; 
  a = 10000; 
  b = 20000; 
  cout << a << endl << b << endl; //Anzeige Neuer Block 
  }  
  //Ab hier wieder Lokal 
  cout << a << endl << b << endl; 
  return 0;  
  }

dann diese ausgabe
10
20
1
2
10000
20000
10000 ** Warum die Werte aus dem eingebetteten Block ???? **
20000 ** Hier müsste doch 10 + 20 stehen ?? **

#include<iostream> 
using namespace std; 

  int a = 10, b = 20; //Definiere Global 
  int main() 
  { 
  cout << a << endl << b << endl; //Anzeige Global 
  int a = 1, b = 2; //Definiere Lokal 
  cout << a << endl << b << endl; //Anzeige Lokal 
  // Neuer Block 
  { 
  /* Anders als eben wird jetzt der Datentyp für diesen
  eingebetteten Block angegeben*/
  int a, b;
  a = 10000; 
  b = 20000; 
  cout << a << endl << b << endl; //Anzeige Neuer Block 
  }  
  //Ab hier wieder Lokal 
  cout << a << endl << b << endl; 
  return 0;  
  }

dann diese ausgabe
10
20
1
2
10000
20000
10 ** 10 + 20 sind die Werte aus dem "äusseren Block" **
20

dEUs

#include<iostream>  
using namespace std;  

  int a = 10, b = 20; //Definiere Global  
  int main()  
  {  
  cout << a << endl << b << endl; //Anzeige Global  
  int a = 1, b = 2; //Definiere Lokal  
  cout << a << endl << b << endl; //Anzeige Lokal  
  // Neuer Block  
  {  
  // int a, b;  
  a = 10000;  
  b = 20000;  
  cout << a << endl << b << endl; //Anzeige Neuer Block  
  }   
  //Ab hier wieder Lokal  
  cout << a << endl << b << endl;  
  return 0;   
  }

Das a und b im inneren Block ist das selbe wie das im äusseren! Jetzt kapiert?

Das a und b im inneren Block ist das selbe wie das im äusseren! Jetzt kapiert?
wenn das so ist, bzw. sein soll dann müßte er das ja auch so anzeigen.

compiler spinnt also ?

Knuddlbaer

#include<iostream>   
using namespace std;   

int a = 10, b = 20;   int main()   
{   
	cout <<"L "<< a <<  "\t" << b << endl;   
	cout<<"G " << ::a << "\t" << ::b << endl;   
	{	
		int a = 1, b = 2; //Definiere Lokal   
		cout<<"L " << a << "\t" << b << endl;
		cout<<"G " << ::a << "\t" << ::b << endl;
		// Neuer Block   
		{   
			a = 10000;   
			b = 20000;   
			cout<<"L " << a << "\t" << b << endl; //Anzeige Neuer Block   
			cout<<"G " << ::a << "\t" << ::b << endl; //Anzeige Neuer Block   
		}    
	//Ab hier wieder Lokal   
		cout<<"L " << a << "\t" << b << endl;   
		cout <<"G "<< ::a << "\t" << ::b << endl;   
	}
	cout<<"L " << a << "\t" << b << endl;   
	cout <<"G "<< ::a << "\t" << ::b << endl;   
	return 0;    
}

Schnapp Dir nen Debugger und staune

Sobald lokal etwas deklariert bzw. definiert (*mal was auf die Goldwage pack*) ist dies sichtbar bis die { zuende geht. Nur weil danach eine neue { kommt ändert sich nix drann. Das was zuletzt gesehen wurde gilt.

An die Globale Variable kommst Du mit :: rann.

Probier das oben mal aus (mim Debugger) vllt. wirds dann deutlicher.

Vellas

kiki schrieb:

#include<iostream> 
using namespace std; 
 
  int a = 10, b = 20; //Definiere Global 
  int main() 
  { 
  cout << a << endl << b << endl; //Anzeige Global 
  int a = 1, b = 2; //Definiere Lokal 
  cout << a << endl << b << endl; //Anzeige Lokal 
  // Neuer Block 
  { 
  /* Anders als eben wird jetzt der Datentyp für diesen
  eingebetteten Block angegeben*/
  int a, b;
  a = 10000; 
  b = 20000; 
  cout << a << endl << b << endl; //Anzeige Neuer Block 
  }  
  //Ab hier wieder Lokal 
  cout << a << endl << b << endl; 
  return 0;  
  }

dann diese ausgabe
10
20
1
2
10000
20000
10 ** 10 + 20 sind die Werte aus dem "äusseren Block" **
20

Hier wird am Ende nicht 10 und 20 sondern 1 und 2 ausgegeben, da die Variablen aus dem lokalen nicht aus dem globalen bereich benutzt werden.

Und da bei deinem ersten Programm am Ende 10000 und 20000 am Ende rauskam stimmt auch, weil du die Variablen im innersten Block nicht neu definiert hast.

Code-Hacker