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



  • 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?


Anmelden zum Antworten