Fun-Soft - Programmierforum

Autor

Thread - Seiten: > 1 <

000
03.08.2009, 16:16 Uhr
banshee

Hallo,

es geht hier umfolgende Zeile:

C++:

uint j = static_cast<uint>(result.length() - 2);

Da result.lenth ja mindestens 2 ist, ist dieser Ausdruck immer >= 0. Welchen Sinn hat dieser static_cast also und wo ist eigentlich der Unterschied zum ganz normalen cast mit (int)<Ausdruck> ?

C++:

std::string FileSystem::evalRelativePath(const std::string& path,
                                         const std::string& basePath) const
{
    std::string result = basePath;
    for(uint i = 0; i < path.length();)
    {
        if(i < path.length() - 2 &&
           path.substr(i, 3) == "../")
        {
            // eine Ebene höher im Verzeichnisbaum aufsteigen
            if(result.length() <= 1) return "[INVALID]";
            char* p_temp = new char[result.length() + 1];
            strcpy(p_temp, result.c_str());
            uint j = static_cast<uint>(result.length() - 2);
            while(j && p_temp[j] != '/') j--;
            p_temp[j] = 0;
            result = p_temp;
            delete[] p_temp;
            result += '/';
            i += 3;
        }
        else if(i < path.length() - 1 &&
                path.substr(i, 2) == "./")
        {
            // ignorieren
            i += 2;
        }
        else
        {
            // Zeichen anhängen
            result += path[i];
            i++;
        }
    }

    return result;
}

Profil || Private Message || Suche

Download || Zitatantwort || Editieren || Löschen || IP

001
03.08.2009, 17:06 Uhr
0xdeadbeef
Gott
(Operator)

In diesem speziellen Fall hätte ich wohl die Konstruktorsyntax benutzt, also

C++:

uint j = uint(result.length() - 2);

, aber auf Typgleichheit zu achten ist sicher keine ganz blöde Idee - es ist durchaus denkbar, dass std::string::size_type und uint Typen unterschiedlicher Länge sind.

(int)<ausdruck> ist in C++ kein wirklich normaler Cast mehr, eher eine Kompatibilitätskiste. Die Syntax ist ziemlich unübersichtlich; Ausdrücke wie

C++:

double d = (double) i / j;

können schon mal Kopfkratzen verursachen, was der Cast jetzt eigentlich castet, wenn man nicht gerade viel mit C-Casts arbeitet. Außerdem können, wenn man mit C-Casts nicht sehr vorsichtig ist, einem schon mal aus versehen cv-Qualifier verloren gehen:

C++:

foo const *p = &bar;

foo *q = (foo*) p; // Brandgefährlich
foo *r = static_cast<foo*>(p); // Compiler-Fehler!

Insbesondere in Templates kann das von großer Bedeutung sein. C-Casts casten halt brutal durch; man könnte sie mit Recht Brechstangencasts nennen. Die *_cast-Operatoren dagegen verstehen die Sprache und verhalten sich entsprechend. Ein anderes Beispiel:

C++:

class foo : private bar { };

foo f;
bar *b = (bar*)&f; // Brachial durchgecastet
bar *b2 = static_cast<bar*>(&f); // Compiler-Fehler, f::bar ist private.

Siehe auch www.acm.org/crossroads/xrds3-1/ovp3-1.html
--
Einfachheit ist Voraussetzung für Zuverlässigkeit.
-- Edsger Wybe Dijkstra

Dieser Post wurde am 03.08.2009 um 17:14 Uhr von 0xdeadbeef editiert.

Profil || Private Message || Suche

Download || Zitatantwort || Editieren || Löschen || IP

Seiten: > 1 < [ C / C++ (ANSI-Standard) ]

ThWBoard 2.73 FloSoft-Edition
© by Paul Baecher & Felix Gonschorek (www.thwboard.de)

Anpassungen des Forums
© by Flo-Soft (www.flo-soft.de)

Sie sind Besucher: