Mein Code bisher:

#include<iostream>
using namespace std;

string zeichenkette;

int laenge = 0;
int i = 0;
int laengeRekursiv(string zeichenkette){

    if(zeichenkette[i] =='\0'){
        return 0;
    }else{
        i++;
        laenge++;
        laengeRekursiv(zeichenkette);
    }
    return laenge;
}

void invertieren(string zeichenkette, int stringlaenge){
    char element;

    if(stringlaenge < 0){
        return;
    }else{
        element = zeichenkette[stringlaenge];
        cout << element;

        invertieren(zeichenkette,--stringlaenge);
    }
    return;
}

int main(){
    bool wiederholung = true;

    while(wiederholung){

        cout << "Eingabe Zeichenkette: ";
        cin >> zeichenkette;

        int stringlaenge = laengeRekursiv(zeichenkette);

        invertieren(zeichenkette, stringlaenge-1);
        cout << endl;

        cout << "Neue Zeichenkette invertieren - ja(1) oder nein(0): ";
        cin >> wiederholung;
    }

    return 0;
}

Obwohl ich damit eine Zeichenkette invertieren kann, hätte ich einige Fragen.
Wenn ich für meine Funktion den Datentyp string als Rückgabewert gerne hätte, wie kann ich das am besten realisieren?
Also wenn ich kein cout in meiner Funktion möchte.

Probiert habe ich es mit:

string invertierteZeichenkette;
int l = 0;

string invertieren(string zeichenkette, int stringlaenge){
    if(stringlaenge < 0){
        return;
    }else{
        invertierteZeichenkette[l] = zeichenkette[stringlaenge];
        l++;
        stringlaenge--;

        invertieren(zeichenkette,stringlaenge);
    }
    return invertierteZeichenkette;
}

Beim Rückgabetyp meiner Abbruchbedingung bin ich mir nicht sicher. Darum habe ich sie vorerst weggelöscht
Kann das in einer ähnlichen Form funktionieren?

Ich würde gerne den ganzen invertierten String zurückgeben als Funktionsergebnis.

Freue mich über jede Hilfe.

Ernsthaft jetzt:
1. Du hast #include <string> vergessen.
2. Es muss nicht zwingendermassen ein '\0' am Ende des Strings stehen. Daher besser zeichenkette.c_str() messen.

Hier mein Ansatz hierfür:

std::size_t StrLen(char const* CStr)
{
	if(*CStr)
	{
		return StrLen(++CStr) + 1;
	}
	return 0;
}
std::size_t StrLen(std::string const& Str)
{
	return StrLen(Str.c_str());
}

Hoffentlich hattet ihr Überladung schon. Sonst einfach die zweite Funktion mit demselben Bezeichner weglassen und die Funktion stattdessen mit StrLen(zeichenkette.c_cstr()); aufrufen.

3. Deine zweite Funktion ist schon recht nahe dran. Ich kommentiere mal:

estrella schrieb:

string invertierteZeichenkette; // Die beiden globalen Variablen hier kann man auch vermeiden
int l = 0;

string invertieren(string zeichenkette, int stringlaenge){
    if(stringlaenge < 0){ // Wäre mit std::size_t nicht nötig gewesen.
        return; // Falscher Rückgabetyp
    }else{
        invertierteZeichenkette[l] = zeichenkette[stringlaenge]; // zeichenkette[stringlaenge] ist von den Bezeichnern her nicht mehr im gültigen Bereich! (ich hab schon gesehen dass du in der main-Funktion -1 gerechnet hast aber dennoch irreführend)
        l++; // Wieso Postfix?
        stringlaenge--; // Dito
        
        invertieren(zeichenkette,stringlaenge);
    }
    return invertierteZeichenkette;
}

Hier mal meine (in-place) Variante, hoffentlich kannst du etwas daraus entnehmen:

void Reverse(std::string& Str, std::size_t Begin, std::size_t End)
{
	if(Begin < End && Begin < --End)
	{
		char Temp = Str[Begin];
		Str[Begin] = Str[End];
		Str[End] = Temp;
		Reverse(Str, ++Begin, End);
	}
}
void Reverse(std::string& Str)
{
	return Reverse(Str, 0, StrLen(Str));
}

Und wenn du darauf bestehst, dass eine Kopie zurückgegeben wird, dann lässt sich das auch einfach wrappen:

std::string ReverseCopy(std::string Str) // Beachte: Call by value, also Kopie
{
	Reverse(Str);
	return Str;
}

Aufgabenstellung:
Schreiben Sie eine Funktion, die einen String, der als globale Variable vereinbart und im Hauptprogramm eingelesen wird, in umgekehrter Reihenfolge wieder ausgibt.

Die Funktion soll ausgeben. "ausgeben" ist nicht "zurückgeben". Also holzwegst Du an der Aufgabenstellung vorbei. Mich würde es wundern, wenn echt <string> gemeint wäre statt char[] bei dieser Aufgabenstellung. Um dabei externe Funktionen zu vermeiden, muß man wohl '\0' am Stringende annehmen. Uih, man darf sicherlich gar nicht *str.end() anschauen. Ich mache zur Sicherheit ein '\0' in meinem Programm dran.
Die Schleife in der main() ist nur lästig.

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

string zeichenkette;

void ausgebenVorwarts(int pos) {
	if(zeichenkette[pos]!='\0') {
		cout<<zeichenkette[pos];
		ausgebenVorwarts(pos+1);
	}
}

void ausgebenRueckwaerts(int pos) {
	if(zeichenkette[pos]!='\0') {
		ausgebenRueckwaerts(pos+1);
		cout<<zeichenkette[pos];
	}
}

int main() {
	cout<<"Eingabe Zeichenkette: ";
	cin>>zeichenkette;
	zeichenkette+='\0';

	ausgebenVorwarts(0);
	cout<<'\n';
	ausgebenRueckwaerts(0);
	cout<<'\n';
}

Oder mit char[] und minimal:

#include<iostream>
using namespace std;

char zeichenkette[80];

void ausgebenRueckwaerts(int pos) {
	if(zeichenkette[pos]!='\0') {
		ausgebenRueckwaerts(pos+1);
		cout<<zeichenkette[pos];
	}
}

int main() {
	cout<<"Eingabe Zeichenkette: ";
	cin.getline(zeichenkette,sizeof(zeichenkette));
	ausgebenRueckwaerts(0);
}

Hat doch auch ne gewisse Schönheit, nur das zu machen, was gefordert war.