Wie Variablen ans Unterprogramm übergeben ?

[Daniel Blum (Gast)]

Hallo!

Kurze Frage, zur Programmierung von Unterprogrammen:
Ich habe eine Haupt - und eine Unterroutine

void main(void)
{
int x;            // für test
test();
}

void test()
{}

Jetzt möchte ich in test am liebsten keine Variable "x" deklarieren, 
sondern
ausschließlich in main(). Allerdings meckert mein Compiler ständig 
Fehler an.
Wie deklariere ich die Variablen denn in main() , oder sogar außerhalb 
der main() Routine richtig,  sodaß ich keine Fehlermeldung bekomme !?


Mfg Daniel

[Tobias (Gast)]

Beispiel

void main(void)
{
int x;            // für test
x = test(x);
}

int test(int x)
{
mach was damit;
return x;
}

[Daniel Blum (Gast)]

Ist das nicht ein bisschen aufwändig?
Falls ich drei Variablen benötige, dann haben ich ein riesen Wust an 
Informationen im Quelltext..!
Gibt es nicht ne besser Lösung?

Danke für den Beitrag!

[Walter (Gast)]

außerhalb von main als globale Variable:

int x;            // für test
void main(void)
{
test();
}

int test()
{
mach was damit;
}

[Hans (Gast)]

Wobei man versuchen sollte globale Variablen zu vermeiden.
So wurde mir das jedenfalls beigebracht im Bezug auf µC Anwendungen.

[Daniel Blum (Gast)]

@Hans
Wie würdest Du es denn machen?
Gibt es keine "Richtline" für eine gute saubere Programmierung?

[Feadi F. (feadi)]

Da gibt es auch noch die Referenz:

void main(void)
{
  int x;            // für test
  test( x );
}

void test( int &x )
{
  x++;
}

> Falls ich drei Variablen benötige, dann haben ich ein riesen Wust an
> Informationen im Quelltext..!
Wenn im Quelltext keine Informationen sind, was ist dann der Sinn 
dahinter? Programmierer müssen schliesslich hart Arbeiten.

Gruß, Feadi

[Patrick D. (oldbug)]

Das Verhalten ist eh 'implementation defined', also schwer zu sagen, was 
passiert, wenn man 'main' nicht als 'int' implementiert.

[Hans (Gast)]

Ich würde die Versionen von Tobias und  Feadi aus Frankreich nutzen! Ist 
doch überhaupt gar kein Problem, alles schön übersichtlich und so.

[Roland Praml (Gast)]

wenn man mehr Variablen übergeben möchte, packt man diese am Besten in 
eine Struct.

und wenn es geht bzw sinnvoll ist immer mit Referenzen arbeiten, das 
spart Kopien

void test (int x) // hier wird x kopiert
{
   x=3; // es wird auf der Kopie gearbeitet
}

void test_ref (int &x)  // hier wird x referenziert
{
   x=5; // es wird auf der Referenz gearbeitet
}

x=1;
test(x);
// x ist immer noch 1 und nicht 3
test_ref(x);
// x ist jetzt 5

[Rufus Τ. F. (rufus)]

C (zumindest C89, das noch sehr verbreitet ist) kennt keine Referenzen.

[Daniel Blum (Gast)]

Ok !! Thema Strukturen... Super Idee...

Dann mach mal bitte nen Vorschlag wie das aussehen soll..!

Falls es nicht so viele Umstände macht !!

mfg Daniel

[Roland Praml (Gast)]

hmm, macht mir jetzt schon zu viel Umstände ;-)

Einfach mal im Quellcode von anderen Projekten rumstöbern und ein paar 
Tricks abschauen...

[Profi (Gast)]

MIT C++
#include<iostream>

void main(void)
{
  int x=5;            // für test
  cout<<test(x)<<std; //6
}

void test( int &x )
{
  x++;
}

MIT C

#include<stdio.h>

void main(void)
{
  int x=5;            // für test
  printf("%d \n",test(&x)); //6
}

void test(int *x)
{
  *x++;
}

[Profi Teil2 (Gast)]

Voriges Mail war mit Wertrückgabe

In C Arbeiten mit Adresse &Variabelnname
und den Pointer * in der Parameterliste in der Methode.
die Pointer müssen in der ganzen Methode mit gezogen werden,
sonst weiss der Compiler nicht welche Adresse gemeint ist.

Bei C++ genügt das & in der Parameterliste in der Methode.

[Tobi H. (tobi-)]

Tolle Profis:

Diese Anweisung  'cout<<test(x)<<std;' kann und wird so nicht 
funktionieren, wenn test als Rückgabetyp void hat. Warum das so ist, 
sollen unsere Profis am besten selbst nachlesen bzw ausprobieren.

[Chris (Gast)]

Nicht nur das, "void main()" war nie und ist nicht zulässig, weder in C 
noch in C++. Neuere gcc-Versionen melden AFAIK sogar einen 
Compile-Fehler, wenn man nicht "int main()" schreibt.

[Rolf Magnus (Gast)]

> Nicht nur das, "void main()" war nie und ist nicht zulässig, weder in C
> noch in C++.

Das stimmt nicht so ganz. In C++ muß der Rückgabetyp tatsächlich 
grunsätzlich immer int sein. In C (zumindest in ISO-C) darf es auch 
andere implementationsspezifische Definitionen von main() geben.