[C++] Unterprogramme

[fre4k]

Hallo
Ich habe in der Schule bald einen Test in C++ , und auf dem letzten hab ich keine ahsogute note bekommen weil ich keine unterprogramme verwendet habe , wir arbeiten mit Borland C++ 5.02 und machen keine achso tollen aufgaben eher nur so zeug zum rechnen. Naja jetzt wollte ich übern und habe Fragen dazu hoffentlich könnt ihr mir da weiterhelfe.

Also nur so zum test hab ich auf die schnelle ein kleins Programm mit einer Unterfunktion geschriben.

#include <iostream.h>
#include <conio.h>
#include <stdio.h>

int eingabe()
{
int n;
cout<<"Bitte geben sie die Spalten - Zeilenanzahl ein:";
cin>>n;

return n;
}

void main()
{
int n;

eingabe();
cout<<n;

getch();

}

Das Proglem ist dass er immer im Hauptprogramm 0 ausgibt, also einen falschen wert ! musst ich das irgendwie in dem fall mit pointern machen , oder wie das heißt , also wo man von den varaiblem die adresse usw angeben muss ?

 

[S!lenceR]

das problem ist, das du int n jeweils lokal innerhalb 2 verschiedener funktionen aufrufst. eine lokale variable ist nur so lange gültig wie die funktion aktiv ist. sprich du arbeitest mit 2 verschiedenen n.
wenn die funktion eingabe aufgerufen wird, schreibt der den wert in sein lokales n. dieser wert ist verworfen nachdem die funktion verlassen wird. wenn er dann wieder zurück in main() springt, ist das dort definierte n wieder gültig, welches allerdings ja keinen wert hat. lösen könntest du das, indem du zb. int n global definierst. also ganz oben vor deinen funktionen schreibst. und alle anderen int ns rausnimmst....
damit hast du ein n das allgemeingültiges n, das du sowojhl von main als auch eingabe ansprechen kannst...
oder du weist in main() n = eingabe() zu, da eingabe ja den wert von seiner var. n zurückliefert

#include <iostream.h>
#include <conio.h>
#include <stdio.h>

int n;

int eingabe()
{
// int n;
cout<<"Bitte geben sie die Spalten - Zeilenanzahl ein:";
cin>>n;

return n;
}

void main()
{
// int n;

 n = eingabe(); // Entweder so dann brauchst du n auch nicht global definieren
// eingabe();     // Oder so, dann muss n global sein
cout<<n;

getch();

}

 

[Boron]

#include <iostream>
using namespace std;

int eingabe()
{
    int n;
    cout << "Bitte geben sie die Spalten - Zeilenanzahl ein: ";
    cin >> n;

    return n;
}

int main()
{
    int x;

    x = eingabe();
    cout << x << endl;  // endl gibt ein Carriage Return nach x aus
                        // und gibt somit alles im Ausgabepuffer aus

    cin.get();  // Programm wartet an dieser Stelle bis Return gedrückt wird.

    return 0;
}

So ist es besser .

Du lässt zwar die eingegebene Zahl n von eingabe() zurückgeben, aber du weist sie keiner Variablen zu. Der Rückgabewert wird also verworfen.
Die 0 die ausgegeben wurde steht nur zufällig an der Speicheradresse von deinem n in der main().

Außerdem verwendest du zwei mal den Bezeichner n für Variablen. Das ist zwar nicht falsch, aber unglaublich verwirrend. Besser ist es unterschiedliche Namen zu verwenden.

conio.h soll nicht verwendet werden, da es Microsoft spezifisch ist, und somit nicht auf andere Systeme (z.B. Linux) portierbar ist.

Korrekte C++ Programme (schließlich verwendest du cin und cout) habe eine int main() und liefern bei Erfolg 0 zurück.

 

[fre4k]

yeah es geht =) da habe ich wieder was neues dazugelernt =), aber es gibt ja noch sowas das nennt sich Pointer, da muss man mit den adressen unteranderen arbeiten von den variablen , leider habe ich das nie verstanden aber wenn ich eine varible global definiere , fällt dann das weg ? also dass ich mit den adressen arbeiten muss ?

 

[Boron]

Einfache Erklärung für Pointer / Zeiger in C/C++

Stell dir vor dein Hauptspeicher ist ein Straße mit Häusern. Jedes Haus hat eine Hausnummer (Speicheradresse).
In jedem Haus kann sich irgendwas befinden, z.B. eine hübsche Frau (Variable).

Wenn du jetzt zu der Frau willst, dann kannst du einfach zu dem Haus hingehen (auf Variable zugreifen).

Wenn du nicht weißt wo das Haus mit der Frau ist, dann fragst du jemanden der es weiß.
Dieser Jemand wohnt auch in der Straße und heißt Herr Zeiger. Der kann dir sagen in welcher Adresse die Frau wohnt.
Wenn die Frau umzieht merkt sich Herr Zeiger einfach die neue Adresse der Frau.

int frau = 5;
int* zeiger = &frau;  // Zeiger merkt sich die Adresse der Frau
// der Operator & vor einer Variablen liefert immer die Speicheradresse der Variablen

// Jetzt machen wir mit der Frau was ;-)
frau = 9;  // direkter Zugriff (wir wissen wo sie wohnt)
*zeiger = 13;  // jetzt haben wir Herr Zeiger gefragt

// Der * Operator fragt die Zeiger-Variable nach dem Wert der Variable wo der Zeiger hinzeigt.

int maedel = 7;  // junges hübsches Ding zieht in anderes Haus ein
zeiger = &maedel;  // Herr zeiger findet das Mädel hübscher als Frau
*zeiger = 12;

 

[fre4k]

ok jetzt habs ich es kapiert doch wann muss ich sowas bei einer unterfunktion verwenden ?

 

[Boron]

Wann du einer Zeiger bei einer Funktion verwenden musst?
Du musst gar nichts!

Was du machen kannst ist Folgendes, obwohl es in diesen einfachen Beispiel ziemlicher Quatsch ist. Aber du willst es ja lernen.

Du kannst der Funktion eingabe() als Parameter eine Variable übergeben, in die dann die eingelesene Zahl geschrieben wird.
Dann kannst du dir den Rückgabewert sparen.

void eingabe( int* zahl)
{
    cout << "Bitte geben sie die Spalten - Zeilenanzahl ein: ";
    cin >> *zahl;
}

int main()
{
    int x;

    eingabe( &x);
    cout << x << endl;  // endl gibt ein Carriage Return nach x aus
                        // und gibt somit alles im Ausgabepuffer aus

    cin.get();  // Programm wartet an dieser Stelle bis Return gedrückt wird.

    return 0;
}

Aber sinnvoll ist es hier wirklich nicht.

Und entgegen dem Tipp von Silencer:
Benutze nie globale Variablen. Das ist böses Voodoo und wird von praktisch allen Informatikern/Programmieren dieser Welt mit der Steinigung bestraft .
Grund ist, dass ein Programm mit globalen Variablen sehr schnell sehr unübersichtlich wird ("Woher habe ich jetzt nochmal die Variable blub? Egal, benutze ich sie halt." Und zack, schon kann es krachen).

 

[fre4k]

juhu alles kapiert =) , hab mal probeweise schnell das programm geschrieben:

#include <iostream.h>
#include <conio.h>
#include <stdio.h>



int eingabe(int* zahl1, int* zahl2)
{


cout << "Zahl1  ";
cin >> *zahl1;
cout << "Zahl2  ";
cin >> *zahl2;

}





void main()
{
int x,y;



eingabe(&x,&y);
cout<<x<<endl;
cout<<y<<endl;

getch();

}

und es klappt so dass der auch 2 Variablen zurückgibt =) , find ich echt super von euch, dass ihr mir geholfen habt =) und noch ein BIG THX @ Boron , dass du dir die ganze mühe gemacht hast
komisch bei euch versth ichs , bei unserem komischen lehrer nicht , naja kein wunder der gibt uns programme zum abtippen und dann sollen wir das kapieren ...

 

[S!lenceR]

Da muss ich Boron zustimmen, Globale Variablen sind nicht wirklich schön und führen schnell zu Verwirrung, zumal der Wert von diversen Funktionen ja geändert werden könnte und man evtl nicht mehr nachvollziehen kann woher die Änderung stammt.

 

[Boron]

Lehrende Menschen (egal ob Schule oder Hochschule) haben die blöde Angewohnheit Dinge so zu erklären, wie sie sind! Also benutzen sie Begriffe und Zusammenhänge die ein Mensch nicht sofort versteht.

Besser ist es aber für kompliziert Sachverhalte (Pointer sind wirklich nicht leicht zu verstehen) Vergleiche zu benutzen (wer hat je versucht Pointer mit hübschen Mädchen zu vergleichen ?).
Wer den Vergleich versteht dem erschließt sich leichter der eigentliche Sachverhalt.

 

[S!lenceR]

Also das mit den hübschen Mädchen war mir auch neu, muss ich mir mal merken

 

[ehenkes]

Hier kannst du die Funktion von Zeigern und Referenzen sehen:

#include <iostream>
#include <conio.h>
using std::cout;
using std::endl;

//globale Variablen
int a = 1;
int b = 2;

void ausgabe()
{
cout << &a << ": " << a << "\t " << &b << ": " << b << endl << endl;
}

void erfolgloser_swap( int x, int y )
{
cout << "Kopien auf dem Stack: " << endl;
cout << &x << ": " << x << "\t " << &y << ": " << y << endl;

int temp = x;
x = y;
y = temp;

cout << &x << ": " << x << "\t " << &y << ": " << y << endl;
cout << "swap nur lokal erfolgreich." << endl;
}

void zeiger_swap( int * x, int * y ) // C-Lösung
{
int temp = *x; // Inhalts-Operator // Dereferenzierungs-Operator
*x = *y;
*y = temp;
}

void referenzen_swap( int & x, int & y ) // C++-Lösung
{
int temp = x;
x = y;
y = temp;
}

int main()
{
cout << "Ausgangssituation: " << endl;
ausgabe();

cout << "Tausch mittels std::swap(x,y): " << endl;
std::swap(a,b); // Methode der Wahl aus der STL
ausgabe();

cout << "Tausch mittels Zeiger: " << endl;
zeiger_swap(&a, &b);
ausgabe();

cout << "Tausch mittels Referenzen: " << endl;
referenzen_swap(a,b);
ausgabe();

cout << "Erfolgloser Tausch, da nur lokale Kopien getauscht werden." << endl;
erfolgloser_swap(a,b);
ausgabe();

cout << "Tausch mittels Register eax und ebx: " << endl;
//swap (a,b)
__asm("mov _b, %eax"); //AT&T Syntax bei Dev-C++
__asm("mov _a, %ebx");
__asm("mov %eax, _a");
__asm("mov %ebx, _b");
ausgabe();

getch();
}