#include <string>
size_type length() const;

The length() function returns the number of elements in the current string, performing the same role as the size() function.

Hört sich ja soweit gut an, doch wie wende ich das ganze in der Praxis an?

#include <string>
#include <iostream>
using namespace std;
string text;
cin>>text;
cout>>size_type length(text);
system("pause");

Klappt nicht.
Wie muss es richtig lauten?

Meine 2. Frage. Ich möchte einen String in einen buffer reinpacken. Dazu habe ich die Funktion strcpy() gefunden (leider c und nicht c++ ist aber doch kompatibel):

#include <string.h>
char *strcpy( char *to, const char *from );

The strcpy() function copies characters in the string from to the string to, including the null termination. The return value is to.

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

string text;
char buf[256];
cin>>text;
strcpy(buf,text);

Klappt leider auch nicht.

Wie ihr mittlerweile warscheinlich festgestellt habe, habe ich einige Elementare Probleme mit der Umsetzung von Referenz Einträgen in richtigen Code.

Was mache ich (alles) falsch?

Vielen Dank für eure Hilfe

Was mache ich (alles) falsch?

So ziemlich alles.
--> http://tutorial.schornboeck.net/inhalt.htm
--> http://www.volkard.de/C++/Tutorial/index.html
--> http://www.c-plusplus.net/cms/modules.php?op=modload&name=Downloads&file=index&req=viewsdownload&sid=2

Kann mir villeicht mal jemand einfach ein beispiel für length undd strcpy schreiben?
Nur die eine Zeile, kein ganzes Programm.

string text;
char buf[256];
cin>>text;
strcpy( buf, text.c_str() );

http://www.cppreference.com/cppstring/c_str.html

Aber ich würd ja bei std::string bleiben, wenn du keine chars brauchst

#include <iostream> // für std::cin und std::cout
#include <string> // für std::string
#include <cstring> // string.h ist im Std nit mehr drin .. heißt cstring

int main()
{
	std::string text;
	char buffer[256];
	std::getline(std::cin, text);
	strncpy(buffer, text.c_str(), 256); // damit wir nicht über die Grenzen hinaus schreiben ...
	std::cout << buffer << " | " << text << std::endl;
}

so ...

#include <iostream>
#include <string>

int main()
{
	std::string text;
	std::getline(std::cin, text);
	std::cout << "String-Length: " << text.length() << std::endl; 
}

wird length richtig genutzt. Und du solltest dir mal Grundlagen nochmal angucken ... std::cout hat keinen >> operator -.-

war ein schreibfehler

muss

cout<<bla

heissen

ich habe einen char array und ich möchte, dass alle teile davon auf "" zurückgesetzt werden wie sie es am anfang waren

Die Referenzen haben vermutlich folgenden Aufbau:

rueckgabe_type  function_name (formal_parameter)

Folgende Methode gibt einen int-Wert zurück und erwartet einen Aufruf mit einem long-Wert und einem char-Wert. Was du mit diesem rückgabewert anfängst ist allein deine Sache und wie diese Funktion arbeitet braucht dich nicht zu interessieren. Du mußt nur wissen was sie machen soll und sie nur mit den entsprechenden Formalparameter aufrufen.

int foo(long a, char b)

Methoden sind Funktionen, die entweder an einem Objekt oder an einer Klasse gebunden sind. Funktionsnamen bzw. Methodennamen dürfen überladen werden. Das wird Polymorphismus (oder so ähnlich) genannt. Das bedeutet daß zwei verschiedene Methoden (Funktionen) den gleichen Namen tragen dürfen. Überladene Funktionen müssen sich dann aber in den Formal-Parametern unterscheiden.
Dazu gibt es jedoch noch eine Menge weiteres zu erzählen.. Vereinfacht ausgedrückt: Um die jeweilige Methode zu "addressieren" muß sowohl der Funktionsname als auch der Formalparameter-Typ gleich sein. Anhand des Rückgabe-Types kann keine Funktion überladen werden.

geht nicht:

void foo() {}
int  foo() {return 0 ;}

geht:

void foo(int  a) {}
void foo(char b) {}

Aufruf einer Klassen-Methode:

Klassenname::methodenname(Formalparameter);

Aufruf einer Objekt-Methode (Member-Method):

Klassenname objekt_name();
objekt_name.methodenname();

bzw.

Klassenname* objekt_name = new Klassenname();
objekt_name->methodenname();

Ich hoffe damit ist deine Frage beantwortet
MfG Gorgoyle