Aber das muss doch auch mit einer Schleife gehen?
Ich erzeuge mir dazu einen String, der mir die Argumente a0 bis a2 erzeugt. Diese wollte ich dann einfach als "name" übergeben.
Nagut, er meckert natürlich: "cannot convert `std::string' to `int*' for argument `1' to `void funktion(int*)'".

Wie kann ich das denn doch hinbekommen? Es muss doch Möglichkeiten dafür geben?

void funktion(int *x) {
     cout << x <<endl;
}

int main() {

    stringstream name;
    string str;

    int *a0 = 0, *a1 = 0, *a2 = 0;
    funktion(a0);
    funktion(a1);
    funktion(a2);

    for (int i = 0; i < 3; i++) {
        name << "a" << i; //setzt mir meine Argumente zusammen
        str = name.str(); //und fügt sie als string aneinander
        cout << str << endl; //macht mir zur Kontrolle eine schöne Liste von a0 bis a2
        funktion(str); //hier soll a0.... a2 übergeben werden

        name.str(""); //damit an str nicht alles angehängt wird, lösch ich die Variable hier
        name.clear();
    }
    system("PAUSE");
    return 0;
}

int *ptrArray[3];

oder aber, da wir hier in C++ sind, besser gleich in einen Vektor:

vector<*int> ptrVector;

Diese Konstruktionen kannst Du dann prima in einer Schleife durchlaufen und Zeiger für Zeiger herausholen und an Deine Funktion übergeben.
Allerdings sollten Deine Zeiger dann besser auch auf vernünftige Speicherbereiche verweisen, oder ist das Absicht, daß sie in Deinem Codeschnipsel alle NULL-Zeiger sind?

Übrigens ist dein Ziel doch sicher eher, int-Variablen zu erzeugen, nicht int-Pointer, oder? Denn du erzeugst hier nicht 3 Pointer, die auf den Wert 0 zeigen...

Vielleicht eher so?

void funktion(int *x) {
	cout << *x <<endl;
}

void main() {
	int ai[3]={0,1,2};
	for(int i=0;i<3;i++) {
		funktion(&ai[i]);
	}
}

Auf die Zeigervariablen *ai habe ich keinen Einfluss. Ebenso kann ich die "funktion(int *x)" nicht beeinflussen.

Ich habe jetzt eine Möglichkeit gefunden, wie ich eine einzelne Variable aus einem Array an meine Funktion übergeben kann. Hier auf mein Beispiel übertragen sieht es folgendermaßen aus:

void funktion(int *x) {
     cout << *x <<endl;
}

int main(void) {
    int A=1;
    int *a=&A; //Zuweisung ient mir nur zum überprüfen. Wichtig ist, dass
               // ich auf keinen der *ai einfluss nehmen kann

    int **ptrArray=&a; //hier muss ich irgendwie alle ai hineinbekommen
    funktion(*ptrArray);

    system("PAUSE");
    return 0;
}

Dieser Code erfüllt genau mein Vorhaben für einen einzelnen Aufruf.
Aber ich kriegs einfach nicht hin, mehrere *ai in den Array zu packen und an die Funktion zu übergeben. Vielleicht könnt ihr mir nochmals Hilfestellung geben?

Lieben Gruß

Dieser Code erfüllt genau mein Vorhaben für einen einzelnen Aufruf.
Aber ich kriegs einfach nicht hin, mehrere *ai in den Array zu packen und an die Funktion zu übergeben. Vielleicht könnt ihr mir nochmals Hilfestellung geben

Deine Funktion arbeitet mit einem Wert, nicht mit n Werten. Also musst du diese über eine Schleife aufrufen. Oder du erzählst uns nicht genügend.

Wenn deine Funktion tatsächlich für Arrays gedacht sein sollte, braucht diese mindestens noch die Angabe der Arraygrößen; dies wird von C-Arrays nunmal nicht irgendwie geliefert.

Edit: Zudem glaube ich an dein Code zu erkennen, das dir noch einige absolute Grundlagen zur Zeigerarithmetik fehlen.

Und fürs erste läuft es jetzt auch. Hier meine Lösung:

int A=1, B=2, C=3;
    int *a=&A, *b=&B, *c=&C;

    int **ptrArray[3]={&a, &b, &c};

    for(int i=0;i<3;i++) {
        funktion(*ptrArray[i]);
    }

Danke für alle Hilfe!