Wie ist dies möglich, ich habe der Methode doch ein "const char*" und kein "std::string" übergeben? Welchen operator muss ich hierfür überladen?

class String{
 char *cStr;

 String(const char *cStr);
 ~String(void);

 String *operator???(const char *cStr); // welcher operator
};

String::String(const char *cStr){
 this->cStr = new char[strlen(cStr)+1];
 strcpy(this->cStr,cStr);
}

String::~String(void){
 delete []this->cStr;
}

String *String::operator???(const char *cStr){
 this->cStr = new char[strlen(cStr)+1];
 strcpy(this->cStr,cStr);
 return this;
}

Wie ist dies möglich, ich habe der Methode doch ein "const char*" und kein "std::string" übergeben? Welchen operator muss ich hierfür überladen?

class String{
public:

  //für 
  //  void out(const String &str);
  //  out("2323dsd");
  String(const char *cStr)
  {
    //...
  }

  //für 
  //   std::cout << str;
  friend std::ostream & <<(std::ostream &os, const String &str)
  {
    //...
  }
};

Ja genau das meine ich, aber soviel ich weiss muss ich es dann so machen:

out(&String("Hallo Welt"));

Ich möchte aber nur:

out("Hallo Welt");

übergeben.

Die String Klasse des std Namespace kann dies und ich frage mich, wie???

Diese Operatorenüberladung brauchst du dann nur für den umgekehrten Fall.
Also wenn du ein String als std::string oder const char* übergeben möchtest.

Warnings:
warning C4996: 'strcpy' was declared deprecated

Errors:
error C2664: 'out' : cannot convert parameter 1 from 'const char [7]' to 'KB_String *'

char *cStr sollte nicht public sein.
Für strcpy braucht's #include <cstring>.

EDIT:
Achso,

void out(KB_String *pStr){ 
 std::cout << pStr->cStr; 
}

Sieh dir nochmal genau an, was als Parameter erwartet wird.

void out(KB_String *pStr){
 std::cout << pStr->cStr;
}

Warnings:
warning C4996: 'strcpy' was declared deprecated

Errors:
error C2664: 'out' : cannot convert parameter 1 from 'const char [7]' to 'KB_String *'

mach mal so:

void out(const KB_String &pStr)
{
 std::cout << pStr->cStr;
}

void out(KB_String *pStr){
 std::cout << pStr->cStr;
}

müsste

void out(KB_String pStr)// Kein Pointer
{
 std::cout << pStr->cStr;
}

heißen.

auch hier:

const char* c = "Hallo!";
KB_String s(c);

wird c kopiert

wenn du den konstruktor automatisch aufrufen lässt (in deinem beispiel) wird der string immer kopiert. Wenn du zusätzlich bei out keine Referenz sondern byvalue übergibts, wird der string zweimal kopiert.

Eben, desshalb will ich es ja auch per pointer oder referenz übergeben, doch beides funktioniert nicht!!

Muss ich dann alle funktionen, welche einen String als parameter haben, überladen, dass kanns ja wohl nicht sein!!

Bsp.

void out(const char *cStr){
cout << cStr;
}

void out(const String *pStr){
cout << pStr;
}

String s1 = "Hallo";
out(&s1);
out(" Welt");

Gibts keine Möglichkeit, dies mit derselben Funktion zu machen??

Eben, desshalb will ich es ja auch per pointer oder referenz übergeben, doch beides funktioniert nicht!!

#include <iostream>
#include <string>

class MeinRadString
{
public:
	MeinRadString(const char *str)
		:	impl(str)
	{
	}

	friend std::ostream &operator<<(std::ostream &os, const MeinRadString &str)
	{
		os << str.impl;
		return os;
	}

private:
	std::string impl;
};

void out(const MeinRadString &pStr) 
{ 
	std::cout << pStr; 
}

int main()
{
	out("Muss ich das Rad unbedingt neu erfinden?\n");
}

Compiling...
teste.cpp
Linking...

Build log was saved at "file://d:\work\C++\tests\teste\Debug\BuildLog.htm"
teste - 0 error(s), 0 warning(s)

Muss ich das Rad unbedingt neu erfinden?
Press any key to continue

Erstmal solltest du davon abkommen, einen Pointer auf KB_String zu uebergeben, wo char* verlangt wird. Damit solche Dinge auch ohne Kopieren funktionieren, wurde ja gerade die Reference in C++ eingefuehrt.

Du kannst nun fuer KB_String einen Ruckgabeoperator definieren (hier kommt dann die Operatorenueberladung ins Spiel), auf dass KB_String auch als const char* zurueckliefern kann. Somit funktionert dann auch dein
out(s1); Denn s1 weiss nun, wie es sich in const char* umzuwandeln hat und es wird auch nur der Pointer auf char uebergeben.

@ssm: Ich finde es schon gut, wenn jemand auch mal hinter die Kulissen schauen moechte.

@ssm: Ich finde es schon gut, wenn jemand auch mal hinter die Kulissen schauen moechte.

Du hast 100% recht! Aber Ishildur versucht einfach nicht zu kopieren, was ihm gezeigt wird.

Du kannst nun fuer KB_String einen Ruckgabeoperator definieren (hier kommt dann die Operatorenueberladung ins Spiel), auf dass KB_String auch als const char* zurueckliefern kann.

Das ist genau das was ich suche, doch wie sieht dieser "Rückgabeoperator" aus?

SeppSchrot schrieb:

@ssm: Ich finde es schon gut, wenn jemand auch mal hinter die Kulissen schauen moechte.

Du hast 100% recht! Aber Ishildur versucht einfach nicht zu kopieren, was ihm gezeigt wird.

Er soll's auch kapieren und nicht kopieren

Er soll's auch kapieren und nicht kopieren

Ich lerne Deutsch

WIE SIEHT DENN NUN DIESER RÜCKGABEOPERATOR AUS?????????

class KB_String
{
//...
  operator const char *() const
  {
    return "so sieht er aus :-)";
  }
//...
};