mehrere private Variable einer Klasse setzen

Artchi

#include <string>

class CRecord
{
public:
    void addRecord();
    void setRecord(std::string &value, std::string &plugin, std::string &options, int x, int y);
    void setm_value(std::string &wert) { m_value=wert; }

private:
    std::string m_value, m_plugin, m_options;

    int m_x, m_y;
    };

void CRecord::setRecord(std::string &value, std::string &plugin, std::string &options, int x, int y)
{
 m_value = value;
 m_plugin = plugin;
 m_options = options;
 m_x = x;
 m_y = y;
}

Wenn du char* hast, hast du ja nur einen Pointer aber keinen reservierten Speicher. Hättest also ansonst mit new Speicher reservieren müssen, bevor du die Parameter mit den Attributen gleich setzt.

Am besten man verzichtet in C++ aber auf alten C-Kram und benutzt gleich Objekte, in dem Fall die string-Klasse. Da kann nichts schief gehen.

erstmal danke für die Antworten.
Was muss denn jetzt bei void setRecord(std::string &value, std::string &plugin, std::string &options, int x, int y);
übergeben werden um ganz doof zu fragen ?
Den wenn ich jetzt string übergebe dann kommt wieder mein Lieblingsfehler Speicherzugriffsfehler.
bei char* kommt error: no matching function for call to `CRecord::setRecord(char&, char*&, char*&, int, int)'*
Man OO macht mir das aber nicht gerade leicht auf C++ umzusteigen

MFG
addision

Artchi

Hem, ist eigentlich nicht schwerer als C. Wenn ein std::string-Parameter erwartet wird, mußt du logischerweise auch ein std::string übergeben. char* ist aber kein std::string, sondern ein char-Pointer. Gell?

Beispiel, wie man die Methode aufruft:

#include <string>

// ...

std::string value = "bla";
std::string plugin = "blabla";
std::string opt = "blub";

// ...

myRecord.setRecord(value, plugin, opt, 3, 2);

Eigentlich ganz einfach, oder? Mit der string-Klasse kann man noch mehr machen. Auf die ganzen strcpy() usw. kannste verzichten, wenn du Strings bearbeiten willst.

Beispiel:

std::string value = "bla";
value.append("blub");      // hängt blub an bla dran.
int i = value.length();            // liefert größe des Strings zurück
value.c_str();             // Falls nötig, gibts es den C++-String auch C-kompatibel zurück ;-)

Infos zu allen string-Methoden findest du hier:

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

dEUs

Artchi schrieb:

Wenn ein std::string-Parameter erwartet wird, mußt du logischerweise auch ein std::string übergeben. char* ist aber kein std::string, sondern ein char-Pointer. Gell?

Witzig... http://www.cppreference.com/cppstring_details.html#Constructors

tag

... damit die benutzerdefinierte Konvertierung von const char* nach std::string klappt, müsst ihr dann aber noch die Parameter des Konstruktors von string& auf const string& umstellen, denn die Konvertierung von const char* braucht ein temporäres Objekt und das kann nicht an eine nicht-konstante Referenz gebunden werden
dann sollte auch myRecord.setRecord("bla", "blubb", "lala", 3, 2); funktionieren

Artchi schrieb:

Hem, ist eigentlich nicht schwerer als C. Wenn ein std::string-Parameter erwartet wird, mußt du logischerweise auch ein std::string übergeben. char* ist aber kein std::string, sondern ein char-Pointer. Gell?
...

Ja habe ich ja versucht ein String zu übergeben da kam aber der Speicherzugriffsfehler siehe letzten Beitrag von mir.
Aber jetzt ist mir aufgefallen das der Speicherzugriffsfehler nicht wegen der Übergabe gekommen ist sondern wieder in der Zuweisung der privaten Variablen einer Klasse.
Wenn ich die Variablen allerdings ausserhalb der ganzen Klasse nehme dann funktioniert die Zuweisung das ist aber nicht der Sinn von OO.
Nochmal der Code zur Veranschaulichung:

record.h

#include <string>

using namespace std;

class CRecord
{
public:
    void addRecord();
    void setRecord(string &value, string &plugin, string &options, int x, int y);

private:
    string m_value, m_plugin, m_options;

    int m_x, m_y;
    };

record.cpp

//string m_value, m_plugin, m_options; //Testweise die Variablen ausserhalb der Klasse definiert dann funktioniert die Zuweisung

void CRecord::setRecord(string &value, string &plugin, string &options, int x, int y)
{
 cout << value << endl; // <- Ausgabe vom übergebenen Parameter funktioniert
 m_value = value; // <- Bei den Aufruf kommt der Speicherzugriffsfehler
 m_plugin = plugin;
 m_options = options;
 m_x = x;
 m_y = y;
}

Übergeben tue ich das Testweise so.

void CRead::ausgabe()
{
CRecord *f;
string test;
test = "Hello World !";
f->setRecord(test, test, test, 10, 5);
}

So wie man sieht will ich inmoment noch garkein char* umwandeln mind. jetzt noch nicht da inmoment ja die Zuweisung der Variablen nicht richtig klappt und ich habe kein blassen schimmer wieso nicht ?

MFG
addision

dEUs

lol ...
Das Problem liegt daran:

CRecord *f;
...
f->setRecord(test, test, test, 10, 5);

f hat keinen Speicher!!!

Artchi

Ja, du mußt erstmal ein Objekt von CRecord anlegen! z.B. so:

void CRead::ausgabe()
{
CRecord *f = new CRecord();  // Neue Instanz auf Heap anlegen
string test;
test = "Hello World !";
f->setRecord(test, test, test, 10, 5);

delete f;  // aber auch wieder vom Heap löschen!!!
}

*f war bei dir ja nur ein Pointer, der noch auf nichts gezeigt hat. Und wenn du einen Pointer erstmal anlegst, ohne etwas zuzuweisen, dann immer null setzen:

CRecord *f = NULL;

Für temporäre Objekte lohnt sich aber eher der Stack:

void CRead::ausgabe()
{
CRecord f(); // Neues Objekt auf Stack anlegen
string test;
test = "Hello World !";
f.setRecord(test, test, test, 10, 5);
}

Artchi

Achja, using namespace in einer header-Datei ist ganz böse und gefährlich! Nur in der Übersetzungseinheit (sprich cpp-Datei!) benutzen!

ahh danke euch allen jetzt funktioniert es
Muss jetzt nur noch meine verkettete Liste von C zu C++ konvertieren. Hab schon gefunden das es mit std::list extra ne Funktion dafür gibt.
Muss mal nach entsprechenden Anleitungen bzw. Beispielcodes suchen hab bis jetzt noch nichts entsprechendes gefunden ist allerdings wieder ein anderes Thema.

MFg
addision