Was bedeutet "#INF"

[net 0]

camper schrieb:

ich hab noch eine:

time = (need - have) / double(prod) / 3600.0;

alle drei varianten haben dieselbe bedeutung.

aber meine ist die einzige, die unter c wie auch unter c++ funzt

[camper]

net schrieb:

camper schrieb:

ich hab noch eine:

time = (need - have) / double(prod) / 3600.0;

alle drei varianten haben dieselbe bedeutung.

aber meine ist die einzige, die unter c wie auch unter c++ funzt

relevanz?

[net 0]

GPC schrieb:

Er verwendet die C++ Casts, während du noch mit den C Casts rumgurkst, unnötigerweise. Die C++ Casts haben den Vorteil, dass es für jeden Zweck einen gibt (static, dynamic, reinterpret, const)...

ich glaube dass die meisten c++ casts verwenden, nur weil's schicker/neuer/schöner aussieht. kennst du ein beispiel das nur mit c++ casts funktioniert und mit c casts nicht?

[.filmor]

Alle dynamic_casts?!

[camper]

fast. alle dynamic_casts, die einen polymorphen typ benötigen. es war ja nie der sinn der 'neuen' cast syntax, neue konvertierungen einzuführen. die, die wir haben, bereiten schon genug kopfzerbrechen.

[GPC]

net schrieb:

GPC schrieb:

Er verwendet die C++ Casts, während du noch mit den C Casts rumgurkst, unnötigerweise. Die C++ Casts haben den Vorteil, dass es für jeden Zweck einen gibt (static, dynamic, reinterpret, const)...

ich glaube dass die meisten c++ casts verwenden, nur weil's schicker/neuer/schöner aussieht.

Nun ja, ich fand die neuen Casts zu Beginn ja echt hässlich, inzwischen geht's einigermaßen. Daran liegt's wohl eher nicht. Und wenn ich ehrlich bin, verwende ich schon C++ Sprachmittel, wenn's welche gibt. Warum auch nicht? Ich programmiere ja schließlich C++ und nicht C (Äquivalent zu dieser Situation wäre die #define und const Geschichte).

kennst du ein beispiel das nur mit c++ casts funktioniert und mit c casts nicht?

Die Frage wurde ja bereits beantwortet. Sie sind einfach klarer im Vergleich zu C Casts. Siehe auch Lektion 2 von MEC++ von Scott Meyers.

MfG

GPC

[Chris++ 0]

GPC schrieb:

Er verwendet die C++ Casts, während du noch mit den C Casts rumgurkst, unnötigerweise. Die C++ Casts haben den Vorteil, dass es für jeden Zweck einen gibt (static, dynamic, reinterpret, const). Das macht klar, wie gecastet werden soll (was auch die Fehlersuche erleichtern dürfte), ein C Cast hingegen castet irgendwie.
Daher: In C++ die neuen Casts verwenden!

Genau deswegen.

[Swordfish]

Vielleicht erbarmt sich doch mal jemand und schreibt einen FAQ Beitrag...

Greetz, Swordfish

[net 0]

GPC schrieb:

kennst du ein beispiel das nur mit c++ casts funktioniert und mit c casts nicht?

Die Frage wurde ja bereits beantwortet. Sie sind einfach klarer im Vergleich zu C Casts. Siehe auch Lektion 2 von MEC++ von Scott Meyers.

aber kann nicht mal jemand einen codebeispiel posten, das nur mit c++-casts geht und mit c-casts z.b. abstürzt oder sich anders verhält?

[Z2]

class a
{
    public:

        virtual ~a() {}
};

class b : public a
{

};

class c : public a
{

};

void test()
{
    b B;
    a *A = &B;

    // C-Cast: undefiniertes Verhalten
    c *C = (c *) A;

    // C++ Cast: 0-Zeiger wird zurückgegeben
    c *C = dynamic_cast<c *> (A);
}

[net 0]

danke.
geht aber nur wen rtti enabled ist, sonst stürzt es ab beim dynamic_cast (bei mir zumindestens). also einen dynamic_cast kann man nicht durch c-casts ersetzen, aber wie ist es z.b. mit static_cast und reinterpret_cast? habt ihr dafür auch beispiele, die zeigen dass man sie in c++ nicht durch c-casts ersetzen kann?

[camper]

net schrieb:

habt ihr dafür auch beispiele, die zeigen dass man sie in c++ nicht durch c-casts ersetzen kann?

es gibt ein paar seltene fälle. nähmlich dann wenn ein static_cast oder ein reinterpret_cast erlaubt wären (in dem falle verhält sich C-cast wie ein static_cast) und wir ein reinterpret_cast benötigen.

// wir wollen viele verschieden (POD-)Ts binär in einem stream speichern. weil das ewige gecaste beim user unschön ist, schreiben wir eine template-klasse. verschiedene versionen:
// 1 (C-style cast über pointer)
template<typename T>
bool write_binary(std::ostream& s, const T& arg)
{
    return s.write( (const char*)&arg, sizeof arg );
};

// 2 (reinterpret_cast über pointer)
template<typename T>
bool write_binary(std::ostream& s, const T& arg)
{
    return s.write( reinterpret_cast< const char* >( &arg ), sizeof arg );
};

// 3 (C-style cast über array)
template<typename T>
bool write_binary(std::ostream& s, const T& arg)
{
    return s.write( (const char (&)[sizeof arg])arg, sizeof arg );
};

// 4 (static_cast über array)
template<typename T>
bool write_binary(std::ostream& s, const T& arg)
{
    return s.write( static_cast< const char (&)[sizeof arg] >( arg ), sizeof arg );
};

// 5 (reinterpret_cast über array)
template<typename T>
bool write_binary(std::ostream& s, const T& arg)
{
    return s.write( reinterpret_cast< const char (&)[sizeof arg] >( arg ), sizeof arg );
};

varianten 1 und 2 funktionieren, vorausgesetzt, T hat keinen falsch überladenen & operator - das wird wohl meist der fall sein, aber wenn wir können, sollten wir versuchen, nicht davon abhängig zu sein. variante 4 funktioniert nur, wenn T einen passenden konvertierungsoperator hat (oder zufällig mal bereits so ein array ist). variante 5 wird immer das tun, was wir wollen. und variante 3 entspricht variante 4, wenn diese zulässig ist (wir wissen aber nicht, was der konvertierungsoperator in 4 anstellt, wenn er existiert), sonst variante 5. dieser schleichende bedeutungswandel spricht in solchen fällen immer gegen C-style casts.

[Delryn]

Ein weiterer Vorteil wäre, das c++-casts schneller zu finden / leichter zu erkennen sind.

[net 0]

demnach sind gibt es also die c++ casts, um mit mehrdeutigkeiten klarzukommen. naja, c++ hat ja ohne ende mit mehrdeutigkeiten zu kämpfen (man denke da nur an überladene operatoren usw...). jetzt ist mir einiges klarer. danke camper, gutes beispiel