Wie sollte der Standardkonstruktor für die Klasse Person aussehen?

camper

Edit: müll

simon.phoenix

Griese schrieb:

Shade Of Mine schrieb:

habe ich bereits entkräftet

Du meinst vermutlich das, was simon.phoenix geschrieben hat?
void c_func(char* val);

template<class CharType>
std::vector<CharType> GetStringBuffer(const std::basic_string<CharType>& bufferSource){
    return std::vector<CharType>(bufferSource.begin(), bufferSource.end());
}

class Foo{
    public:
        std::string GetFoo() { return fooVar_; }
    private:
        std::string fooVar_;
};

int main(){
    Foo myFoo;
    std::vector fooBuf = GetStringBuffer<char>(myFoo.GetFoo());
    
    c_func(&fooBuf[0]);

   return 0;
}
Das sieht ja höchst ineffektiv aus. Und wie viel da kopiert und erzeugt wird...

Warum soll das jetzt besser als das Rückgeben eines const char*s sein? Bitte um Aufklärung, habe einen möglichen Nachteil des Rückgabetyps const char* nämlich noch nicht entdeckt.

Da hast du schon recht. Aber C-Funktionen erwarten sehr häufig char* und nicht const char*.

simon.phoenix schrieb:

Griese schrieb:
Shade Of Mine schrieb:

habe ich bereits entkräftet

Du meinst vermutlich das, was simon.phoenix geschrieben hat?
void c_func(char* val);

template<class CharType>
std::vector<CharType> GetStringBuffer(const std::basic_string<CharType>& bufferSource){
    return std::vector<CharType>(bufferSource.begin(), bufferSource.end());
}

class Foo{
    public:
        std::string GetFoo() { return fooVar_; }
    private:
        std::string fooVar_;
};

int main(){
    Foo myFoo;
    std::vector fooBuf = GetStringBuffer<char>(myFoo.GetFoo());
    
    c_func(&fooBuf[0]);

   return 0;
}
Das sieht ja höchst ineffektiv aus. Und wie viel da kopiert und erzeugt wird...

Warum soll das jetzt besser als das Rückgeben eines const char*s sein? Bitte um Aufklärung, habe einen möglichen Nachteil des Rückgabetyps const char* nämlich noch nicht entdeckt.
Da hast du schon recht. Aber C-Funktionen erwarten sehr häufig char* und nicht const char*.

const_cast

Ferner gibt's für jene, die ein char* erwarten, einen Ersatz in C++. Ich reden von nicht von solchem Schnickschnack wie strcpy() usw., sondern von solchen C-Funktionen, die schon ein const char* erwarten und auf dieser Basis viel Arbeit erledigen.

interpreter

const_cast ist pfui

interpreter schrieb:

const_cast ist pfui

Anstelle der Funktionen, die ein char* erwarten, benutze ich lieber die Stringmanipulation von std::string und ein const_cast findet sich in keinem meiner Programme.

War lediglich eine Alternative zu dem Code von simon.

Vielleicht habe ich mich gestern nicht deutlich genug ausgedrückt, aber ich habe keinen Plan, wie man das mit einem std::vector umgehen sollte. Würde mich echt interessieren, Beispiel-Code zu sehen. Hat jemand was?

Griese schrieb:

Bitte um Aufklärung, habe einen möglichen Nachteil des Rückgabetyps const char* nämlich noch nicht entdeckt.

Daran hat sich übrigens immer noch nichts geändert. Ihr widersprecht mir doch die ganze Zeit, den als Rückgabetyp zu benutzen. Warum?

simon.phoenix

Griese schrieb:

Vielleicht habe ich mich gestern nicht deutlich genug ausgedrückt, aber ich habe keinen Plan, wie man das mit einem std::vector umgehen sollte. Würde mich echt interessieren, Beispiel-Code zu sehen. Hat jemand was?

Griese schrieb:

Bitte um Aufklärung, habe einen möglichen Nachteil des Rückgabetyps const char* nämlich noch nicht entdeckt.

Daran hat sich übrigens immer noch nichts geändert. Ihr widersprecht mir doch die ganze Zeit, den als Rückgabetyp zu benutzen. Warum?

const char* als Rückgabetyp ist imho sehr nervig, wenn man was stack-generiertes returnen will (bestes beispiel imho const char* std::exception::what()):

const char* foo::what(){
    std::string errorInf;
    GenerateMyError(errorInf);
    return errorInf.c_str(); // Es wird dann auf einen nicht mehr existenten Zeiger gezeigt
}

Deshalb std::string >>>> const char* :p

Shade Of Mine

Griese schrieb:

Ferner gibt's für jene, die ein char* erwarten, einen Ersatz in C++. Ich reden von nicht von solchem Schnickschnack wie strcpy() usw., sondern von solchen C-Funktionen, die schon ein const char* erwarten und auf dieser Basis viel Arbeit erledigen.

std::vector

Vielleicht habe ich mich gestern nicht deutlich genug ausgedrückt, aber ich habe keinen Plan, wie man das mit einem std::vector umgehen sollte. Würde mich echt interessieren, Beispiel-Code zu sehen. Hat jemand was?

std::vector<char> vec;
vec.resize(1024);
GetStringFormSomewhere(&vec[0], vec.size());

Daran hat sich übrigens immer noch nichts geändert. Ihr widersprecht mir doch die ganze Zeit, den als Rückgabetyp zu benutzen. Warum?

Wenn du intern einen std::string hast, kannst du _nur_ char const* nach außen geben. Das bringt dir oft nichts, weil du damit keine vernünftigen setter hast.

denn ein

char buffer[1024];
GetStringFromSomewhere(buffer, sizeof(buffer));
obj.set(buffer);

suckt doch, oder?

Weiters ist die manipulation von rohen zeigern fehleranfällig, sollte also vermieden werden.

und es ist langsamer (weil unnötig kopiert wird) im gegensatz zu std::vector

// So und wenn ihr gerafft habt, was hier geschieht, dann könnt ihr mir ja
// noch einmal etwas über interne Daten einer Klasse erzählen.

Du bist ja wohl einer von der ganz 1337en Sorte ..

Ich kann natürlich dem Compiler und dem Standard den Kampf
ansagen und solch miese Hacks hernehmen ..

Ich könnte natürlich einfach die Header-Datei hernehmen und
das private durch public ersetzen. So .. schreib mir doch jetzt
bitte einen C++-Header der sich selbst gegen sowas schützt, danke.

Ts, .. "angeblich" bereits 24 Jahre in der Branche und wohl noch
kein einziges vernünftiges Buch vor der Nase gehabt ..

finix

Guest352342 schrieb:

Ich könnte natürlich einfach die Header-Datei hernehmen und
das private durch public ersetzen.

Und dann?

Walli

Mecnels: Ich habe noch einen guten Trick für dich, falls du mal mit fremdem Code arbeiten musst, der unnötigerweise das Prinzip des information hiding beherzt.

#define private public