int main()
{
char* p=0;
int* x=0;
init(p,x);
...
}

void(char* p, int* x)
...

ich bekomme aber immer nur compiler errors oder das programm stürzt ab kann mir jemand sagen wie die richtige syntax dafür ist?

void init(int*);

int main()
    {
        int a; // KEIN Pointer, es muss ein Objekt exisitieren,
        init(&a); // Welches hier geändert wird.
    }

void init(int* var)
    {
        *var = 1234;
    }

Schöner ist es allerdings mit Referenzen:

void init(int&);

int main()
    {
        int a; // KEIN Pointer, es muss ein Objekt exisitieren,
        init(a); // Welches hier geändert wird.
    }

void init(int& var)
    {
        var = 1234;
    }

Du kannst keine NULL-Pointer definiern, welche ins Nirvana zeigen und dann versuchen das Nirvana zu verändern. (Okay, es ginge doch, nur ist das in diesem Falle unsauber und trägt auch nicht gerade zur Lesbarkeit des Codes bei)

Grüße... Heiko

void(char* p, int* x)

Da fehlt doch was.

2. Wenn das dort eingesetzt ist, fehlt immer noch eine Forwardeclaration, oder gleich die ganze Funkton nach oben.

edit: Aber schön ist das definitiv nicht! Guck dir evtl mal std::auto_ptr oder die boost-Zeigerwrapper an, da wird man glücklicher mit.

Danke Badestrand das habe ich gesucht aber warum ist das nicht schön?

Weil es gefährlich ist und dir sehr schnell Memoryleaks geben kann. (Wer kümmert sich um das aufräumen des mit new reservierten Platzes?)

#include <iostream>
using namespace std;

//zeiger werden über zeiger übergeben
void init(char **c, int **i)
{
    //reserviert speicheradressen und weist sie den zeigern zu
    *c = new char; //der operator * derferenziert
    *i = new int;

    //weist den reservierten speicheradressen (nicht den zeigern!) werte zu
    **c = 'a'; //hier wird zwei mal derferenziert, da nicht der per zeiger übergebene zeiger, sondern der inhalt der adresse gemeint ist, die er als wert hat.
    **i = 4711;
}

//zeiger werden über referenzen übergeben
void finish(char *&c, int *&i)
{
    //gibt die speicheradressen frei
    delete c;//durch die übergabe per referenz wird automatisch dereferenziert, so dass der operator * hier nicht nötig ist.
    delete i;

    //weist den zeigern 0 zu, um ihre ungültigkeit überprüfbar zu machen
    c = 0;
    i = 0;
}

//zeiger werden übergeben, indem ihr wert,
//also die gespeicherte adresse,
//kopiert wird
void test(char *c, int *i)
{
    if (c != 0)
    	cout << "c zeigt auf den Wert " << *c << "\n";
    else
        cout << "c darf nicht dereferenziert werden, da es die Spezialadresse 0 als Wert hat!\n";

    if (i != 0)
    	cout << "i zeigt auf den Wert " << *i;
    else
        cout << "i darf nicht dereferenziert werden, da es die Spezialadresse 0 als Wert hat!";

    cout << endl;
}

int main()
{
    char *p=0;
    int *x=0;

    test(p, x);
    init(&p, &x);
    test(p, x);
    finish(p, x);
    test(p, x);
}

in der tat ist es aber so, dass heutzutage die meisten betriebssysteme den speicher nach dem ende des programms wieder frei geben. des problem ist, wenn programme lange laufen, wie zum beispiel server, und immer wieder speicher reserviert wird, für den keine freigabe erfolgt, wenn er nicht mehr benötigt wird.

Die init-Funktion lässt auch Schlüsse zu, dass du es mal mit Klassen probieren solltest. Hier kannst du angeforderten Speicher durch den Desktruktor "automatisch" freigeben lassen. In vielen Fällen kommt man aber drum herum, dynamischen Speicher mittels new anfordern zu müssen. Die STL bietet viele nützliche Hilfsmittel (std::vector<T>, std::string, std::list<T>, um einige zu nennen), welche dir die Arbeit mit dyamisch angeforderten Speicher abnehmen.

Wenn du bestehende Variablen einfach ändern willst, dann ist die Übergabe per Referenz die sinnvollste (m.E.).

Die 800 Zeilen Quelltext lassen sich bestimmt um einiges reduzieren und übersichtlicher gestalten, wenn man die oben genannten Sprachmittel verwendet.

Grüße... Heiko