http://www.nnseek.com/e/de.comp.lang.iso-c++/ Posts for de.comp.lang.iso-c++ Tue, 16 Jan 2007 07:47:08 PST http://www.nnseek.com/ http://www.nnseek.com/img/64.png 64 64 NNSeek http://www.nnseek.com/e/de.comp.lang.iso-c++/einlesen_von_aufz5hlungstypen_34342005t.html http://www.nnseek.com/e/de.comp.lang.iso-c++/einlesen_von_aufz5hlungstypen_34342005t.html
ich habe folgendes Problem:

Ich möchte einen von mir definierten Aufzählungstyp entweder von der
Standardeingabe oder aus einer externen Datei einlesen. Leider funktioniert
das nicht ohne weiteres. Unten habe ich das Problem kurz dargestellt.

#include
#include
#include

using namespace std;

enum TYP { eins, zwei, drei};

int main()
{
    string input("datIn");
    ifstream IN(input.c_str());
    TYP t;

    cin >> t;  // Fehlermeldung

    return 0;
}

Ist es möglich, für Aufzählungstypen einen Eingabeoperator zu definieren ?
Oder wie lässt sich das Problem lösen.

Ich bedanke mich schonmal im Voraus für Vorschläge

Posted In: de.comp.lang.iso-c++

2 Comments

Reply

]]> Tue, 16 Jan 2007 07:47:08 PST http://www.nnseek.com/e/de.comp.lang.iso-c++/richtiger_header_oder_34200949t.html http://www.nnseek.com/e/de.comp.lang.iso-c++/richtiger_header_oder_34200949t.html
was ist nach C++-Standard die richtige Header-Datei?

#include

oder

#include

Danke

Posted In: de.comp.lang.iso-c++

no comments

Reply

]]> Mon, 15 Jan 2007 08:14:46 PST http://www.nnseek.com/e/de.comp.lang.iso-c++/c_sleep_unsigned_int_seconds_33532277t.html http://www.nnseek.com/e/de.comp.lang.iso-c++/c_sleep_unsigned_int_seconds_33532277t.html
Ich komm direkt zur Sache weil es schon relativ spät ist:

Gibt es in C++ eine Funktion wie sleep() aus unistd.h welche X
Millisekunden wartet?
Hier in meinem Linuxsystem erwartet die Funktion nämlich Sekunden, ich
brauche allerdings eine welche Millisekunden warten kann.

Also z.B.
int sleep(unsigned int msec);


Und bitte keine Win-Api Funktionen, ich sitze an einem Linuxsystem und hab
vor daran zu bleiben.

MfG
Moritz Ulrich

Posted In: de.comp.lang.iso-c++

5 Comments

Reply

]]> Fri, 12 Jan 2007 18:42:30 PST http://www.nnseek.com/e/de.comp.lang.iso-c++/buchempfehlung_zur_c_nutzung_gesucht_33442165t.html http://www.nnseek.com/e/de.comp.lang.iso-c++/buchempfehlung_zur_c_nutzung_gesucht_33442165t.html
mit den Features der Sprache C++, d.h. wie Klassen deklariert werden, was
Zugriffschutz ist, wie eine Ableitung funktioniert und was Polymorphismus
ist usw. kenne ich mich mittlerweile aus. Allerdings fehlt mir das
Wissen/Verständnis wann was warum in der Praxis einzusetzen ist.

Also vielleicht etwas mehr Gewicht auf Konzepte als auf die Sprache, aber
bitte doch anhand von C++.

Vielleicht hat der eine oder andere von euch in dieser Hinsicht eine
Empfehlung für mich.

Grüße,
Jürgen

Posted In: de.comp.lang.iso-c++

22 Comments

Reply

]]> Fri, 12 Jan 2007 03:27:19 PST http://www.nnseek.com/e/de.comp.lang.iso-c++/wert_von_non_type_template_parametern_33441909t.html http://www.nnseek.com/e/de.comp.lang.iso-c++/wert_von_non_type_template_parametern_33441909t.html
ich habe das folgende Problem: ich habe eine template-Funktion mit
non-type Parameter:

template
void f();

Jetz möchte ich das template für bestimmte N explizit spezialisieren:
template<>
void f<0>() {}

template<>
void f<42>() {}

// etc

Soweit so gut. Aber: ist es denn irgendwie möglich in der
Implementierung von f<...>() auf den konstanten template-Parameter
zuzugreifen? Natürlich könnte ich überall wo ich ihn brauche
explizit den Wert einsetzen, aber das erscheint mir fehlerträchtig.
In jeder Spezialisierung ein
static const int PARAM(0); // oder 42 oder...
zu definieren ist vielleicht besser, aber auch nicht sehr schön, durch
copy/paste ist da leicht ein Fehler passiert. Ausserdem ist es
eigentlich nicht einzusehen, dass ich den Wert des Parameters nochmal
angeben muss, wenn er doch schon explizit (sic) da steht.

Ist euch das auch schon aufgestoßen und wenn ja, wie geht ihr da vor?

Danke schon im Voraus
Norbert

Posted In: de.comp.lang.iso-c++

2 Comments

Reply

]]> Fri, 12 Jan 2007 03:25:16 PST http://www.nnseek.com/e/de.comp.lang.iso-c++/standard_zuweisungsoperator_kann_nicht_benutzt_wer_33442421t.html http://www.nnseek.com/e/de.comp.lang.iso-c++/standard_zuweisungsoperator_kann_nicht_benutzt_wer_33442421t.html
Torsten Robitzki schrieb...
> Der vom Compiler erzeugte Zuweisungsoperator der Elemente funktioniert
> nicht, da die Referenzen nicht zugewiesen werden können. Entweder Du
> schwenkst auf Zeiger um, oder definierst den Zuweisungsoperator selber.

Könnte man überhaupt eine Rferenz 'verbiegen'? Also so etwas:

#include
using namespace std;

struct FOO {
FOO(int &val) : x(val) {}
FOO &operator=(const FOO &rhs) {
// ??? x=rhs.x, aber nicht als Value
return *this;
}
void Set(int val) {x=val;}
int &x;
};

int i=1, j=2;

int main() {
FOO a(i), b(j);
a.Set(3); // setzt i=3
cout << "i=" << i << " j=" << j << endl;
a = b;
a.Set(4); // soll jetzt j setzen
cout << "i=" << i << " j=" << j << endl;
}

Ausgabe ist
i=3 j=2
i=4 j=2

Mit Referenz 'verbiegen' soll aber
i=3 j=2
i=3 j=4
rauskommen. Mir ist aber kein 'legaler' Weg
bekannt.


- Heinz

Posted In: de.comp.lang.iso-c++

10 Comments

Reply

]]> Fri, 12 Jan 2007 01:08:25 PST http://www.nnseek.com/e/de.comp.lang.iso-c++/standard_zuweisungsoperator_kann_nicht_benutzt_wer_33441141t.html http://www.nnseek.com/e/de.comp.lang.iso-c++/standard_zuweisungsoperator_kann_nicht_benutzt_wer_33441141t.html >
> Der vom Compiler erzeugte Zuweisungsoperator der Elemente funktioniert
> nicht, da die Referenzen nicht zugewiesen werden können. Entweder Du
> schwenkst auf Zeiger um, oder definierst den Zuweisungsoperator selber.
>

Ok, erst einmal an alle, die mir auch diese Antwort gegeben haben:
Vielen Dank!

Warum aber hat der Compiler ein Problem damit, eine Referenz zu
kopieren? Die Referenz in dem neu erzeugten Objekt soll einfach auf das
gleiche Objekt verweisen, wie auch in der Klasse von der kopiert wurde!?
Ich kann doch sonst auch jederzeit etwas schreiben wie

string x = "hallo";
string& x_ref1 = x;
string& x_ref2 = x_ref1;


!??


Viele Grüße Boris

Posted In: de.comp.lang.iso-c++

2 Comments

Reply

]]> Thu, 11 Jan 2007 15:07:23 PST http://www.nnseek.com/e/de.comp.lang.iso-c++/lokale_klasse_in_funktions_template_33441397t.html http://www.nnseek.com/e/de.comp.lang.iso-c++/lokale_klasse_in_funktions_template_33441397t.html Anscheinend (eigentlich ja nichts neues) gibt es in Visual C++ 6 hier einen
Bug:

template
void Test(A a1)
{
class T
{
T() {}

A a2;
};
};

Im Hauptprogramm rufe ich z.B. Test(5) auf.
Bei diesem Code erhalte ich einen Internen Compiler-Fehler (1001, msc1.cpp
Zeile 1794).
(Wenn ich den Konstruktor weglasse, dann compiliert er anstandslos.)

Daher habe ich eine globale Template-Klasse für T eingeführt (für jedes
Funktionstemplate
brauche ich eine passende Klasse).

Gibt es hier auch einfachere (kürzere) Alternativen, den Fehler zu umgehen?
Ich brauche das Funktionstemplate in verschiedenen Versionen, und damit
jedes mal eine neue Template-Klasse...

Alex

Posted In: de.comp.lang.iso-c++

2 Comments

Reply

]]> Thu, 11 Jan 2007 14:07:20 PST http://www.nnseek.com/e/de.comp.lang.iso-c++/l9schen_von_objekten_31606133t.html http://www.nnseek.com/e/de.comp.lang.iso-c++/l9schen_von_objekten_31606133t.html > int& func()
> {
> int z = 17;
> return z;
> }
> und
> int mz = func();
> bzw.
> int& mz = func();
>
> In ersterem Fall enthält aber mz immerhin 17, in letzterem Blödsinn.
> In Perl wird ein out-of-scope-Objekt erst gelöscht wenn es keine Referenz
> mehr darauf gibt. In C++ dürfte es anders sein (ja/nein?),

Ja, in Perl werden effektiv alle Objekte über das Äquivalent eines
boost::scoped_ptr verwaltet.

> also auch verständlich wenn die Sache schiefgeht.
> Ist es dann nur Zufall bzw. compilerabhängig wenn mz im ersten Fall den
> korrekten Wert enthält?

Zufall.

Real existierende Maschinen haben einen Stack. Den kannst du dir
vorstellen als ein dickes Array nebst Pointer
int stack[10000000];
int sp = 0;
void push(int x) { stack[++sp] = x; }
int pop() { return stack[sp--]; }
Die lokale Variable 'z' wird nun, z.B. per push, auf dem Stack angelegt.
Dann holt sich jemand eine Referenz darauf (für den Rückgabewert)
int& rueckgabewert = stack[sp];
und schlussendlich wird die Variable mittels pop freigegeben. Solange
nun niemand push aufruft, bleibt der an der Adresse gespeicherte Wert
gültig. Bei 'int mz = func()' tut das der Compiler glücklicherweise
nicht. Allerdings ist es zum Beispiel möglich, dass zwischen der
Rückkehr aus func() und der Zuweisung des Rückgabewertes an mz ein
Signal eintrifft, welches push verwendet. In dem Fall würde ein
ungültiger Wert ankommen.

Formal ist das, was du tust, undefiniertes Verhalten, und es kann
prinzipiell alles passieren.


Stefan

Posted In: de.comp.lang.iso-c++

no comments

Reply

]]> Fri, 05 Jan 2007 05:33:56 PST http://www.nnseek.com/e/de.comp.lang.iso-c++/l9schen_von_objekten_31606389t.html http://www.nnseek.com/e/de.comp.lang.iso-c++/l9schen_von_objekten_31606389t.html
> [zitierter Text ausgeblendet]
>
> int& func()
> {
> int z = 17;
> return z;
> > [zitierter Text ausgeblendet]
>
> und
> int mz = func();
> bzw.
> int& mz = func();
>
> meckert gcc in beiden Fällen zwar "warning: reference to local variable `z'
> returned".
Sollte mich auch wundern, wenn er es einmal nicht tut ;-)

> In ersterem Fall enthält aber mz immerhin 17, in letzterem Blödsinn.
> In Perl wird ein out-of-scope-Objekt erst gelöscht wenn es keine Referenz
> mehr darauf gibt. In C++ dürfte es anders sein (ja/nein?), also auch
> verständlich wenn die Sache schiefgeht.
In dem ersten Fall funtioniert das Beispiel, da gleich nach dem
Rücksprung noch der korrekte Wert auf dem Stack steht. Von der Referenz
wird der aktuelle Wert ausgelesen (17) und in nach mz kopiert. Ergo ist
das, was dann im folgenden mit dem Stack passiert egal.
In dem zweiten Fall merkst Du Dir die Referenz und sobald ein neuer
Funktionsaufruf stattfindet wird der Stack an der Stelle überschrieben
und dort stehen plötzlich "neue" Werte drin. C++ passt nie darauf auf,
was Du mit Speicher, Zeigern oder Referenzen machst. Es ist alles in der
Hand des Programmierers.

> Ist es dann nur Zufall bzw. compilerabhängig wenn mz im ersten Fall den
> korrekten Wert enthält?
Ich würde mich nicht darauf verlassen, dass das funktioniert (nicht
umsonst warnt dich der Compiler). Ich kenne mich mit dem Standard nicht
ganz so gut aus aber ich kann mir schon vorstellen, dass nicht gesagt ist,
was mit dem Stack, der frei wird passieren soll. Damit wäre es
compilerabhängig und kann sich jeder Zeit ändern.

Bernhard

Posted In: de.comp.lang.iso-c++

1 Comment

Reply

]]> Fri, 05 Jan 2007 05:33:45 PST