Hi,

ich habe folgende Fragen zu lokale und globale Variablen in C:

1. Unter welchen Voraussetzungen können zwei lokale Variablen den gleichen Namen haben?

2. Unter welchen Voraussetzungen können zwei globale Variablen den gleichen Namen haben?

Gruss

data-bear

HI

Ich bin zwar echt nicht der C-Checkerm aber ich poste jetzt mal IMO

zu 1:

Wenn sie z.b. im gleichen Unterprogramm sind, dann nicht, da ja dann das Programm nicht weiss, welche du meinst-

Wenn sie aber z.b. in 2 verschiedenen unterprogrammen sind, dann ist es kein Problem.

zu 2:

Gar nicht im selben Programm, denn wie in bei 1: wüsste ja das Programm nicht, welche du gerade meinst.

Aber "Haus" und "haus" ist möglich, da diese Namen ja nicht gleich sind (case sensitiv). Würd davon aber abraten, da dann dein Programm ziemlich unübersichtlich wird ...

So und jetzt warte ich auf ein Verbesserung von einem wirklichen C-Checker

cu

alligator

Original geschrieben von alligator

zu 1:

Wenn sie z.b. im gleichen Unterprogramm sind, dann nicht, da ja dann das Programm nicht weiss, welche du meinst-

Wenn sie aber z.b. in 2 verschiedenen unterprogrammen sind, dann ist es kein Problem.

Ich bin mir nicht entgültig sicher, aber ich glaube das in verschiedenen Blöcken (if-Blocken, Schleifen etc.) innerhalb einer Funktion sind auch gleichnamige Variablen möglich sind. Ob das sinnvoll ist so etwas zu machen ist aber klar eine andere Frage.

Man kann Namespaces (in C & C++) definieren und die Variablen dann durch den Namespace differieren, obwohl sie selber tatsächlich innerhalb ihres Bereiches den selben Namen haben. Da muß man dann einfach die Variable mit Namespace::Name ansprechen.

In C++ wird im Grunde genommen bei Objekten und Klassen das ganze nur unter dem Deckmantel des Klassen-Namespaces für Klassenvariablen und dem Punktoperator bei Objekten, bzw. Pfeiloperator bei Objektzeigern versteckt. Innerhalb von Klassen gilt jedoch dasselbe: Jede Klasse kann jede Variable mit selbem Namen beinhalten.

Wenn man sich den Namespace betrachtet wird der betrefffende Bereich in {} geschrieben, was einem Anweisungsblock entspricht, wodurch die Variablen nur nach innen innerhalb der Klammern bekannt sind, wie bei einer Funktion, Methode, Do-while-schleife o.ä..

Namespaces können auch lokal definiert werden, wordurch sich alles innerhalb wie lokale Variablen bei der Assemblerprogrammierung funktionieren, auch wenn die Namensgleichen Variablen im selben Anweisungsblock stehen.

Nebenbei gibt es noch den unnamed Namespace, den man wie eine static-Definition verwenden kann mit dem Unterschied, daß der Compiler nur in dessem Bereich diese Variablen überhaupt erkennt und ansprechen kann und sie anderswo einfach nicht existieren. Tatsächlich sind diese Namespace-Variablen dann konstante Speicherplätze und werden nicht bei Funktionsaufrufen, etc. auf dem Stack reserviert.

Am besten sieht man das im MSDN-Beispiel:

namespace unique { namespace-body }

using namespace unique;

namespace { int i; } // unique::i

void f() { i++; } // unique::i++

namespace A {

namespace {

int I; // A::unique::i

int j; // A::unique::j

}

}

using namespace A;

void h()

{

I++; //error: unique::i or A::unique::i

A::i++; // error: A::i undefined

j++; // A::unique::j++

}

Achso, natürlich verhalten sich vorkompilierte Objektfiles, DLLs, usw. deren Aufruf durch extern irgendwas oder sowas wie Loadlibrary() über die Module-Handles eingebunden werden natürlich genauso als ob sie einen eigenen Namespace hätten, allerdings sind deren Variablen ja schon vorher abgearbeitet und deshalb auch unbekannt, selbst wenn man denselben Namen verwendet!

lokale variablen können mit Blöcken verschieden-viel wiederholt werden, wobei jede Variable nur im jeweiligen eingelschlossenen { } -Block gültig ist.

int main(int argc,char**argv)

{

int a = 1;

{

int a = 2;

{

int a = 3

// und so weiter

]

}

}