wenn du so freundlich wärst und parameter-array und übergabewert-array definieren könntest...

deklaration einer funktion, die ein (int) array übernimmt und nichts zurückgibt:
void foo (int []);
deklaration einer funktion, die ein (int) array übernimmt und eines zurückgibt:
int * foo (int []);
- - , die ein array einer bestimmten größe nimmt und nix zurückgibt:
void foo (int [42])

und damit folgende beispiel definitionen:
void foo (int x[]) { cout << x[10]; }
int *foo (int x[]) { x[10] = 10; return x; }
void foo (int x[42]) { x[22] = 21; }

Zitat von beefy

Ich verstehe nichts von C++ und benutze auch nicht die ung. Notation, mich würde aber trotzdem interessieren warum diese in C++ obsolet sein sollen..?

Sollte vielleicht besser heissen "durch C++ unnoetig geworden".
Du hast nicht nur eine kleine Menge eingebauter Typen (char, int und zeiger darauf), sondern kannst dir eigene definieren - inklusive Vererbung und Polymorphie. Wie willst du das in der ungarischen Notation darstellen?
IMHO ist ein aussagekraeftiger Name viele Male besser als jedes Praefix (das hab ich sicher oben auch schon gesagt)
Objekte sollten ausserdem idR nur relativ kurz existieren. Da vergisst man den Typ schon nicht.
Ausserdem hab ich mehr Tipparbeit.
Verschlimmbessere mir die Lesbarkeit.
In C++ ist es schlicht unnoetig irgendwelche Praefixe, egal ob in ungarischer Notation, fuer Klassen, oder fuer Elementvariablen einzufuehren.
Es geht einfach nur um die (Un)notwendigkeit

Also...
Zuerst einmal heftige Kritik an den Leuten, die euch das beigebracht haben, jetzt nach 5 Jahren C++ unter ISO Standardregeln..
Der Header iostream.h sowie stdio.h sind veraltet. Tja, nix zu machen. Im "neuen" (5 Jahre alten) C++ Standard gibt es dafür die Header iostream und cstdio.

#include <iostream>
#include <cstdio>
using namespace std;

Die Namen sind in den neuen Headern aber alle im Namensraum std untergebracht, also muss man sie mit einer using direktive sichtbar machen (oder mit using deklarationen, wie auch immer man es bevorzugt - oder immer explizit)

Dann:
zu "void main": Main muss immer "int" zurückgeben. Ebenfalls im Standard, sowohl im C als auch im C++ Standard. Es gab nie eine "void" Version in C++.
Ein standardkonformer Compiler (zum Beispiel g++) würde den Code gar nicht erst kompilieren.

Zum Thema globale Variablen: Ich hoffe ihr wisst, dass es eine Unart ist, sie zu benutzen.
Wenn's nun aber vorgegeben ist, so wie hier, dann kann man nix machen.

Ich hoffe außerdem, dass ihr die string Klasse von C++ kennt.

IMHO eine total dumme Aufgabe: Ihr werdet immer Librarys benutzen dürfen, vor allem die vom Standard definierten. Wozu etwas programmieren, dass es schon längst gibt?!

Zurück zum Code von Kongo.
So eine riesige Funktion solltest du in mehrere kleine aufsplitten. Ein solches Trumm ist schwer wartbar und schlecht erweiterbar.
Die ungarische Notation ist in C++ obsolet. Niemand sollte sie mehr verwenden.
Aussagekräftige Namen sind 100mal besser als jedes Präfix.
IMHO machen sie den Code nur noch schwerer lesbar.
Außerdem verwendest du new. Ich sehe aber keine delete (bzw. delete[]). Da entstehen schnell riesige Speicherlöcher.

Bleiben wir gleich beim Thema "erweiterbar".
Schonmal versucht, mit deiner Version ein

replace("ein","absolut kein");
replace("absolut kein","ein");

durchzuführen?
Speicherzugriffsfehler - ist die Ausgabe auf meiner Konsole
Da stimmt etwas nicht.

Naja, hier ein Vorschlag von mir, um diese Aufgabe zu lösen:

#include <iostream>
#include <cassert>
using namespace std;


char global_ist_kaese[100] = "Das ist ein Teststring und eine Banane";

namespace my { //namen immer schön kapseln


      //ein paar grundlegende sachen
     //ptrdiff_t ist das ergebnis einer subtraktion von zwei zeigern
	std::ptrdiff_t strlen (const char *str) {
		const char *ptr = str;
		while (*ptr++); return ptr-str;
	} 


    //gibt true zurück, falls der anfang von str dasselbe ist wie what.
	bool begin_eq (const char *str, const char *what) {
                assert(strlen(str) > strlen(what)); //kommt in der release version natürlich raus
		while (*what) {
			if (*str++ != *what++) return false;
		}
		return true;
	}

    //kopiert ohne abschließende null von from nach to
	void copy (char *to, const char *from) {
		while (*from) *to++ = *from++;
	}

   //ersetzt alle what in str mit with.
	void strrepl (char *str, const char *what, const char *with) {
              //temporärer string mit inhalt des globalen
		char *del, *tmp = del = new char[strlen(str)];
		copy(tmp,str);
	     //zum aufspeeden	
		size_t lwith = strlen(with)-1;
		size_t lwhat = strlen(what)-1;

		while (*str++ = *tmp++) {
			if (begin_eq(tmp,what)) {
				copy(str,with);
				tmp+=lwhat;
				str+=lwith;
			}
		}
		//niemals vergessen!
		delete [] del;
	}


}
//und jetzt: wir wollen die aufgabenstellung nicht vernachlässigen
void die_besagte_funktion () {
	my::strrepl(global_ist_kaese, "ein", "absolut kein");
}


int main() {

   cout << global_ist_kaese << endl;
   my::strrepl(global_ist_kaese,"ein","absolut kein");
   cout << global_ist_kaese << endl;
   my::strrepl(global_ist_kaese,"absolut kein","ein");
   cout << global_ist_kaese << endl;	


//achja: return 0 wird von standardkonformen Compilern am Ende immer automatisch eingefügt.
}

Da lässt sich allerdings sicher noch was rausholen, performancetechnisch.
Naja, nur mal ein Denkanstoß und Mahnzeichen.

Für Fragen:
http://www.c-plusplus.de/forum
Im C++ Subforum bekommt ihr eure Antworten

cya