Dumme Frage

Shinja

Oder nutze std::cout.

groovemaster

Die Frage ist nicht dumm, aber der Threadtitel.

Dummy2332

Wusste es nicht zu formulieren, und dachte mir dass sowas eigentlich n selbstgänger sein sollte.
hab den Code jetzt so abgeändert :

--------------------------------
int main()
{
using std::string;
char* pNAME;
pNAME = "Ahnung.";
printf ("Ich hab keine %s ", pNAME);
return 0;
}
---------------------------------

Hab zwar keine Ahnung wieso das jetzt funktioniert, aber es funktioniert
Schätze mal ich sollte mich ne Runde mit Pointern beschäftigen.

Mario Sandler

Du solltest dir vll. erstmal klarwerden was du programmieren
willst. Dein code ist nämlich bsi jetzt stinknormales C.

Such dir am besten ein C++-Tutorial wenn du C++ lernen willst.
In C++ benutzt man std::cout zur Ausgabe. Dann hast du auch kein Problem
mehr mit den strings.

LordJaxom

Ja, Du kannst natürlich auch jegliche hier vorgeschlagene Lösung ignorieren und den "offensichtlichsten" Weg wählen.

camper

Dummy2332 schrieb:

Wusste es nicht zu formulieren, und dachte mir dass sowas eigentlich n selbstgänger sein sollte.
hab den Code jetzt so abgeändert :

--------------------------------
int main()
{
using std::string;
char* pNAME;
pNAME = "Ahnung.";
printf ("Ich hab keine %s ", pNAME);
return 0;
}
---------------------------------

Hab zwar keine Ahnung wieso das jetzt funktioniert, aber es funktioniert
Schätze mal ich sollte mich ne Runde mit Pointern beschäftigen.

besser wäre, printf zu vergessen (und höchstens irgendwann viel später darauf zurückzukommen).

das ist aber falsch :p

Das mag zwar u.U. funktionieren - Allerdings wird hier Speicher beschrieben, der deinem Prog nicht gehört

entweder:

char * ch = "Bla, bla...";

oder:

char * ch;
ch = new char[16];
strcpy(ch, "Bla, bla...");
delte[] ch;

Gruß, Winnie

camper

Winnie01 schrieb:

das ist aber falsch :p

Das mag zwar u.U. funktionieren - Allerdings wird hier Speicher beschrieben, der deinem Prog nicht gehört

huh? Da wird nichts in irgendeinen Speicher geschrieben. Das ist 100% standardkonformer Code. Das es - möglicherweise - schlechter Code ist, spielt dabei erst mal keine Rolle.

LordJaxom

Winnie01 schrieb:

das ist aber falsch :p

Das mag zwar u.U. funktionieren - Allerdings wird hier Speicher beschrieben, der deinem Prog nicht gehört

Interessant. Wenn Du uns jetzt noch zeigen magst wo hier Speicher beschrieben wird?

char * ch = "Bla, bla...";

ist hier exakt dasselbe wie

char * ch; ch = "Bla, bla...";

Zeiger auf ein char (4 Byte):

char * ch;

und beim

ch = "irgendaw";

wird im Speicher geschrieben, wo keins vorher mit new angeforder war -> also ins Leere...

Habe ich da im Unterricht etwa gepennt?

Dies ist auch möglich und kein Fehler (aber definitiv falsch):

char * c;
c = new char[2];
c = "bla, bla...";

frohe Weihnachten :xmas1:

Simon2

Winnie01 schrieb:

Zeiger auf ein char (4 Byte):
char * ch;
und beim
ch = "irgendaw";
wird im Speicher geschrieben, wo keins vorher mit new angeforder war -> also ins Leere.......

Nein !
Der Zeiger ch wird auf den Anfang des Stringliterals "irgendaw" gesetzt.
Kopiert oder geschrieben wird da nichts.

Dies hier:

Winnie01 schrieb:

Zeiger auf ein char (4 Byte):
...
[cpp]char * c;
c = new char[2]; // (*)
c = "bla, bla...";

hingegen hinterlässt verwaiste 2 Byte, die Du bei (*) allokierst, in der Folgezeile aber ihre Adresse "vergisst".

Gruß,

Simon2.

LordJaxom

Winnie01 schrieb:

wird im Speicher geschrieben, wo keins vorher mit new angeforder war -> also ins Leere...

Nö, in den Speicher schreiben tun strcpy und Konsorten. Hier wird einfach ein Zeiger auf einen konstanten String im Datenbereich des Programms in die Zeigervariable c gelegt. Ist wie gesagt exakt das gleiche wie

char * c = "bla, bla...";

Dies ist auch möglich und kein Fehler (aber definitiv falsch):
char * c;
c = new char[2];
c = "bla, bla...";

Korrekt, denn hier wird erst ein Zeiger auf neu allokierten Speicher in eine Zeigervariable gelegt, der dann durch einen Zeiger auf einen konstanten String im Datenbereich des Programms ersetzt wird, womit Du Dich der Möglichkeit beraubt hast, den allokierten Speicher jemals wieder freizugeben

littlejohn

um nochmal auf die ausgangsfrage zu antworten:

int main()
{
using std::string;
string name;
name = "Ahnung.";
printf ("Ich hab keine %s ", name[b].data()[/b] );
return 0;
}

name ist nur die Stringinstanz. Um an die in der Klasse gespeicherten daten zu kommen, gibts die data()-funktion.

THX 1138

#include <string>
#include <iostream>

int main()
{
    std::string name = "Ahnung.";
    std::cout << "Ich hab keine " << name << std::endl;
    return 0;
}

So, und jetzt verwirrt den armen OP nicht mit dem Pointer Quark :p

camper

THX 1138 schrieb:

#include <string>
#include <iostream>

int main()
{
    std::string name = "Ahnung.";
    std::cout << "Ich hab keine " << name << std::endl;
    return 0;
}

So, und jetzt verwirrt den armen OP nicht mit dem Pointer Quark :p

wieder #include <ostream> vergessen

Dummy2332

Witzig wie so eine "dumme frage" für soviel interesse sorgt
Ich kann nicht mehr 100% folgen, denke mal ich werd mir das vorgeschlagene tutorial mal zu gemüte führen.
klingt spannend und ich hab ja zeit :>
Also danke für die hilfe.

in C++ würde ich es so machen:

#include <iostream>
#include <string>

class Ausgabe
{
    private:
        std::string _s;

    public:
        Ausgabe() : _s(0) {}
        Ausgabe(std::string Text);

        ~Ausgabe() {}

        void sehen() const;
};

Ausgabe::Ausgabe(std::string Text)
{
    _s = Text;
}

void Ausgabe::sehen() const
{
    std::cout << _s.c_str() << std::endl;
}

int main()
{
    Ausgabe a("Ich habe keine Ahnung!");

    a.sehen();

    return 0;
}

bin für alle Verbeserungsvorschläge natürlich offen

Gruß, Winnie

camper

Winnie01 schrieb:

bin für alle Verbeserungsvorschläge natürlich offen

alles streichen?

Winnie01 schrieb:

in C++ würde ich es so machen:

#include <iostream>
#include <string>

class Ausgabe
{
    private:
        std::string _s;

    public:
        Ausgabe() : _s(0) {}
        Ausgabe(std::string Text);
        
        ~Ausgabe() {}

        void sehen() const;
};

Ausgabe::Ausgabe(std::string Text)
{
    _s = Text;
}

void Ausgabe::sehen() const
{
    std::cout << _s.c_str() << std::endl;
}

int main()
{
    Ausgabe a("Ich habe keine Ahnung!");
    
    a.sehen();
    
    return 0;
}

bin für alle Verbeserungsvorschläge natürlich offen

Gruß, Winnie

nich akzeptiert? Warum?