Wie verwende ich Einträge aus der C++ Befehlsreferenz?



  • Ich möchte folgende Referenz benutzen um herauszufinden, wie ich die Lenge eines strings ermittle.
    http://www.cppreference.com/
    Gefunden habe ich folgenden Eintrag:

    #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





  • ooops mir ist grad was aufgefallen - der ganze code oben steht natürlich in der main funktion drin (hab ich aber nur im beitrag vergessen)

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



  • size_type l;
    l = length(text);
    // oder
    cout << length(text);
    
    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



  • Hmm ...

    #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 -.-



  • cout>>bla

    war ein schreibfehler

    muss

    cout<<bla

    heissen



  • mit welchem befehl kann ich denn inhalt einer variable löschen? auch eines arrays?

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



  • #include <cstring> 
    
    char array[] = "Das ist mal nen Test...";
    memset(array, 0, sizeof(array));
    


  • Wer mit C++ arbeitet sollte nicht auf alte C-Mittel zurückgreifen, nimm "std::string"s und nicht char-Arrays ...





  • Das war aber nicht seine Frage.



  • Ich hoffe ich habe deine Frage richtig verstanden..

    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



  • GENAU dass wollte ich wissen, danke :p



  • nur woran sehe ich ob es eine objekt, klassen, etc. methode ist?


Log in to reply