habe die Funktion so implementiert das sie ein char* erwartet,
(weil ich das mit dem char[] nicht hinbekommen habe)

gibt es jetzt noch eine Möglichkeit herauszufinden wie groß das ursprüngliche array war?

Oder kann ich evtl. doch irgendwie mit dem char[] arbeiten, hab es nur noch nicht ganz verstanden ?

char[] und char* sind bei Übergabe an Funktionen das gleiche. Und nein, es ist allgemein nicht möglich bei Übergabe von Arrays an Funktionen deren Länge heraus zu finden.
Mögliche Gegenmaßnahmen:
- Länge mit übergeben
- Anfang und Ende übergeben
- Array in Klasse kapseln. Das gibt's auch schon fertig und nennt sich std::vector.

- '\0' an das Ende anhängen
- wie in Pascal in das erste char-Element die Länge reinschreiben (die maximale Länge ist dann halt 255 Zeichen)

SeppJ schrieb:

Es gibt sogar einen speziellen vector für char, der nennt sich std::string.

Und std::string ist ein typedef für std::basic_string<char>.
Es gibt auch wstring (für basic_string<wchar_t>) und in C++0x auch noch u16string und u32string und vielleicht auch noch u8string.

char[] ist in erster Linie ein unvollständiger Typ. Als solches kann er in drei Kontexten auftauchen:

• Bei einer Deklaration eines Arrays (unbekannter Länge) und statischer Lebensdauer
• Bei einer Definition mit Initialisierungsliste (der Compiler zählt für uns die Eelemente in der Liste und macht aus dem unvollständigen Typen einen vollständigen)
• Als Typ eines Funktionsparameters, wobei in Wirklichkeit ein char* draus gemacht wird.

(gilt natürlich nicht nur für char )

Beispiele:

extern const char nachricht[];

// Typ von nachricht ist noch unvollständig
// sizeof(nachricht) geht noch nicht.
// "pointer to array decay" sowie Elementzugriff klappt aber schon

extern const char nachricht[] = "RTFM";

// Typ von nachricht ist  const char[7]
// sizeof(nachricht) liefert ab hier auch 7

void anzeigen(const char msg[])
{
  // Typ von msg ist tatsächlich const char*
  // sizeof(msg) == sizeof(char*)
  cout << msg;
}

int main() {
  anzeigen(nachricht);
}

gibt es jetzt noch eine Möglichkeit herauszufinden wie groß das ursprüngliche array war?

man könnte es doch theoretisch so machen, oder sollte man so etw. lieber vermeiden

[ EDIT ]

#include <iostream>

void fkt(char (&ar)[8])
{
    std::cout << sizeof(ar);
    std::cout << std::endl << ar;
}

int main()
{
    char ar[] = "Test123";
    fkt(ar);

    getchar();
    return 0;
}

MBreuer schrieb:

gibt es jetzt noch eine Möglichkeit herauszufinden wie groß das ursprüngliche array war?

man könnte es doch theoretisch so machen, oder sollte man so etw. lieber vermeiden

Das ist eine schicke Schreibweise für wxSkips Vorschlag, eine \0 anzuhängen. Das geht natürlich und ist auch die übliche Vorgehensweise, wenn man in C Strings behandelt. Jedoch ist allein aus der Angabe des Threaderstellers nicht klar, ob er mit C-Strings arbeitet oder ob das char-Array einem anderen Zweck (bei dem Nullterminierung nicht in Frage kommt) dient.

Das mit der Referenz ist natürlich überflüssig.

In diesem Fall nicht unbedingt, da dort tatsächlich der Typ der Referenz ein Array von 8 Zeichen ist. Damit funktioniert auch der sizeof Operator wieder "wie erwartet". Ist im Zusammenhang mit Templates häufig anzutreffen.

template<size_t N>
void blank_out(char (&a)[N]) {
    assert(sizeof(a) == N);
    std::fill(a, a+N-1, ' ');
    a[N-1] = '\0';
}

char (&a)[N]

krümelkacker schrieb:

Das mit der Referenz ist natürlich überflüssig.

In diesem Fall nicht unbedingt, da dort tatsächlich der Typ der Referenz ein Array von 8 Zeichen ist.

Dweb hat es für nötig gehalten, seinen Beitrag abzuändern. Vorher stand dort char* const& ar und nicht char (&ar)[N] .

ich möchte ein char[] an eine Funktion übergeben,
gibt es jetzt noch eine Möglichkeit herauszufinden wie groß das ursprüngliche array war?

joa, am Anfang hatte ich "eine Reference auf einen Zeiger gepostet",
aber das hat ja eigentlich net viel gebracht, weil er in der Funktion die Größe des Arrays wissen will ... deswegen umgeändert.

/*
        Reference auf ein Array:
            Die Klammern "()" musste du machen,
            weil du sonst ein Array mit 'size' Referencen anlegst,
            anstatt eine Reference auf ein Array.

        Hier z.B. eine Reference auf eine int-Variable:
            int x;
            int& ref = x;
    */

    char array[] = "Test123";
    char (&reference_auf_array)[8] = array;

ich möchte ein char[] an eine Funktion übergeben,
gibt es jetzt noch eine Möglichkeit herauszufinden wie groß das ursprüngliche array war?

template<typename _Ty, size_t _n>
size_t GetArraySize(_Ty (&array)[_n]) { return _n; }