class Test
{
public:
	Test(void);
	Test(char* str);
	~Test(void);
	void getTo(char &res);

private:
	char* from;
	char* to;	
};

im Konstruktor Test(char* str) wird str zerlegt und die variablen from und to gefüllt. Das mache ich so:

Test::Test(char* str)
{
	from = new char();
	to = new char();
	memcpy(from, "test", 4);	
	from[4]='\0';
	memcpy(to, "testxyz", 7);
   to[7]='\0';
}

in der Methode getTo(char &res) soll dann "To: " und der Wert von to auf res geschrieben werden.

void Test::getTo(char &res)
{

	sprintf(&res, "To: %s", to)
}

in res dann auch das was ich will allerdings ist to dann ein Bad Pointer.
Ich möchte to aber noch in anderen Methoden der Klasse verwenden.
Kann mir jemand sagen wo ich einen Fehler mache??
Wenn ich

to = new char();

im Konstruktor weglasse gehts nicht.

Darüberhinaus übergibst Du der Funktion GetTo eine Referenz auf ein Zeichen, war das beabsichtigt? Jedenfalls dürfte der Schreibvorgang dann ziemlich schiefgehen. Wenn Du bei C-Strings bleiben willst, musst Du der Methode GetTo einen Zeiger auf ein Char-Array liefern (wie Du es mit new char[] erzeugt hast).

Andere Frage: Warum nutzt Du dafür nicht std::string?

Hab jetzt mal new char() in new char[] geändert. Hab aber dann immernoch danach einen bad pointer.

ich übergebe getTo eine Referenz auf ein char-array....

Sorry, Zeiger mein ich

Test::Test(const char* ptr)
{
    std::size_t len = std::strlen(ptr) / 2 + 1;
    m_from = new char[len];
    std::strncpy(m_from, ptr, len - 1);
    len = std::strlen(ptr) - (len - 1) > len ? len + 1 : len;
    m_to = new char[len];
    std::strncpy(m_to, &ptr[len], len - 1);
}

Test::~Test()
{
    delete [] m_to;
    delete [] m_from;
}

...

in deiner getToübergibst du eine referenz, dann kannst (mußt?) du das "&" beim verwenden weglassen.

wieso nimmst du keinen string? macht das um einiges leichter ^^

ich unterstütze:

LordJaxom schrieb:

...Andere Frage: Warum nutzt Du dafür nicht std::string?

qwer123 schrieb:

...
wieso nimmst du keinen string? macht das um einiges leichter ^^

Dann würde aus Deinem Code:

class Test
{
public:
   Test();
   Test(string const& s) {	from = "test";	to = "testxyz"; }
	// Alternativ mit "Initialisierungsliste" : Test(string const& s) : from("test"), to("testxy") {}
	string getTo() { return string("To: ") + to; }
   // Destruktor brauchst Du gar nicht
private:
	string from, to;
};

Ist doch wohl kürzer, sicherer, einfacher, ....

Ach ja: Du schreibst:

nala schrieb:

im Konstruktor Test(char* str) wird str zerlegt und die variablen from und to gefüllt.

Davon sehe ich in Deinem Code nichts....

Gruß,

Simon2.