Problem z rzutowaniem

[Slynx]

Mam problem z rzutowaniem klasy bazowej na pochodną, co jest dla mnie stosunkowo dziwne ( co innego w drugą stronę;p ).
Na samym początku zastosowałem standardowe rzutowanie z C, czyli:

KOD cpp:   �  UKRYJ  �

KOD cpp:   �  POKAŻ  �

// przykładowo
TDerieved^ derObject = (TDerieved^ )GetBaseClassObject(someObject);
 

Potem szybko przeleciałem po internecie i znalazłem, że obiekt klasy bazowej na pochodną powinno się rzutować właśnie w ten sposób lub za pomocą static_cast.
Więc wrzuciłem static_cast:

KOD cpp:   �  UKRYJ  �

KOD cpp:   �  POKAŻ  �

// przykładowo
TDerieved^ derObject = static_cast<TDerieved^ >(GetBaseClassObject(someObject));
 

Uruchomiłem i wszystko kompletnie się zawiesiło. Procesor nie obciążony, z pamięcią też nie chulał. Mimo, że był standardowo w trybie debuggowania, nie mogłem go zatrzymać / wyłączyć. Zawiesił również Visuala ( co zdarzyło mi się pierwszy raz by aplikacja w trybie debuggowania zawiesiła środowisko). Nie chcę dalej kombinować, bo nie jestem, aż tak zaznajomiony z tematem rzutowania.

Przy okazji jeszcze jeden problem z rzutowaniem (tamten wystąpił podczas ładowania zadań, ten podczas ładowania ustawień, więc Log programu zaczął świecić na czerwono;p).
Chodzi o rzutowanie obiektu na typ String. Mam taki kod:

KOD cpp:   �  UKRYJ  �

KOD cpp:   �  POKAŻ  �

// _settings jest słownikiem
Void TSettings::AddValue(Object^ key, Object^ value)
{
        if (!_settings->ContainsKey((String^)key))
        {
                _settings->Add((String^)key, (String^)value);
        }
        else
        {
                _settings[(String^)key] = (String^)value;
        }
};
 

Klucz (key) może być jedną z 6 klas enum oraz typem String, wartość (value) String, Boolean lub int. Więc żeby nie robić masy funkcji, chciałem podawać argumenty typem Object. Wiem, że można to zapisać

KOD cpp:   �  UKRYJ  �

KOD cpp:   �  POKAŻ  �

Convert::ToString(key);
 

I (mam nadzieję) działa poprawnie, ale chciałem tak jak w pierwszym kodzie, bo hmm... lepiej wygląda.
----------
Ok, ok. Co do drugiego to już rozumiem. Object jest klasą bazową dla tych typów, ale przy konwersji obiekt jest traktowany pod typem jaki powstał, tj. Jako, że klas enumerycznych rzutować na String^ nie można to nic nie zmieni, że ja sprowadzę to do Object, to nadal klasa enumeryczna Mój błąd, nie pomyślałem.
---------
Ehem, już wiem dlaczego static_cast spowodował taki katastrofalny błąd, a dlaczego dynamic_cast spowodował jedynie błąd w Logu programu - NullReference. Ale nadal nie wiem czemu nie mogę zrzutować klasy bazowej do pochodnej.

[polymorphism]

A z safe_cast próbowałeś?

(...) znalazłem, że obiekt klasy bazowej na pochodną powinno się rzutować właśnie w ten sposób lub za pomocą static_cast.

static_cast to to samo co rzutowanie w pierwszej podanej przez Ciebie wersji (tej z nawiasami), tyle że w stylu C++. Do rzutowania w dół bardziej nadaje się dynamic_cast.

[Slynx]

Dalej to samo. InvalidCastOperation, nie można rzutować obiektu <klasy bazowje> na typ <klasy pochodnej>.

[polymorphism]

No to najwidoczniej obiekt, który próbujesz zrzutować, nie jest klasy (lub pochodny od klasy) TDerieved _{(tu masz błąd ortograficzny)}.

[Slynx]

static_cast to to samo co rzutowanie w pierwszej podanej przez Ciebie wersji (tej z nawiasami)[...]

Chyba nie do końca. static_cast wykorzystuje się gdy ma się pewność poprawnego rzutowania z Typu na Typ, dlatego to co wpisałem na początku w połączeniu ze static_cast kompletnie zawiesiło program, bo rzutowanie nie było poprawne, tj. błędne. Natomiast gdy użyłem rzutowania z C, to zwrócił nullptr jak robi to dynamic_cast w przypadku nieudanego rzutowania. Więc jeśli już to byłoby rozwiązanie pomiędzy static a dynamic cast.

Ale do tematu. Spróbuję dokładniej odzwierciedlić te klasy, byś miał jakieś podstawy by twierdzić że klasa bazowa nie jest klasą bazową

Bazowa:

KOD cpp:   �  UKRYJ  �

KOD cpp:   �  POKAŻ  �

#pragma once
#include "Theader.h"

namespace xxx
{
        namespace yyy
        {
                using namespace System;
                using namespace System::Collections;
                using namespace System::Drawing;

                public ref class TBase
                {
                public:
                        // -----------------------------------------------------------------
                        // --------------------------- FIELDS ------------------------------
                        // -----------------------------------------------------------------

                        String^ field1;

                        String^ field2;

                        Int64 field3;

                        // -----------------------------------------------------------------
                        // -------------------------- LISTS -----------------------------
                        // -----------------------------------------------------------------

                        // List of download accounts
                        Generic::List<Theader^ >^ list1;

                        // List of forward accounts
                        Generic::List<Theader^ >^ list2;
                        // -----------------------------------------


                        // -----------------------------------------------------------------
                        // --------------------------- Other ------------------------------
                        // -----------------------------------------------------------------

                        // Other field1
                        String^ otherField1;

                        // Other field2
                        String^ otherField2

                        String^ Getfield1();
                        String^  Getfiel2();
                        Int64^ Getfield3();

                        // -----------------------------------------------------------------
                        // ---------------------------- METHODS ----------------------------
                        // -----------------------------------------------------------------

                       
                        TBase
                                (
                                String^ fileld1,
                                String^ field2,
                                Int64 field3,
                                );

                        TBase();
                       // Reszta to zwykłe funkcje. Trochę operacji na tych zmiennych.
                };
        }
}
 

Pochodna

KOD cpp:   �  UKRYJ  �

KOD cpp:   �  POKAŻ  �

#pragma once
#include "Otherheader.h"

namespace xxx
{
        namespace yyy
        {
                using namespace System;
                using namespace System::Collections;

                public ref class TDer : TBase
                {
                public:
                        // -----------------------------------------------------------------
                        // ---------------------- ENUM CLASSESS ----------------------------
                        // -----------------------------------------------------------------

                        enum class Eder1 {State1, State2, State3};

                        Eder1 derState;

                String^ Tder::GetderState()
                {
                        return Convert::ToString(this->derState);
                };

                        Otherheader^ down;
                        Tder();
                        Tder
                                (
                                String^ field1,
                                String^ field2,
                                Int64 field3,
                                );

                        // -----------------------------------------------------------------
                        // ----------------------------- Other Data ---------------------
                        // -----------------------------------------------------------------

                        Generic::List<int>^ someData;

                        String^ andString;

                        String^ GetandString();

                         // Zwraca elementy someData tyle że w Stringu.
                        String^ GetsomeData();
                };
        }
}
 

I tak by to wyglądało. Drugą klasę pomijam, bo generuje ten sam błąd.
Co mogę dodać... nie wszystkie zmienne są inicjowane, brak metod wirtualnych. Nie wiem co może być istotne.

[polymorphism]

Natomiast gdy użyłem rzutowania z C, to zwrócił nullptr jak robi to dynamic_cast w przypadku nieudanego rzutowania.

Widocznie taka specyfika C++/CLI. Wcześniej nieco się rozpędziłem. W przypadku wskaźników rzutowanie w stylu C to raczej reinterpret_cast, a nie jak wcześniej pisałem static_cast, który jest nieco bezpieczniejszy - następuje sprawdzanie zgodności typów w czasie kompilacji.

KOD cpp:   �  UKRYJ  �

KOD cpp:   �  POKAŻ  �

public ref class TDer : TBase { ... }

TBase musi być publicznie dziedziczona, ponieważ teraz klasa TDer nie może być traktowana z zewnątrz jako pochodna TBase.


___
p.s. to 'T' przed nazwami klas to zwyczaj przejęty z Delphi. W C++ stosuje się 'C' (od Class) lub po prostu nic się nie dodaje. Taka drobna uwaga...

[Slynx]

To "T" to ot tak dodałem, jako przykład. W rzyczywistym programie klasy oznaczone dużą literką T to klasy wykorzystywane jedynie jak struktury do przechowywania pewnych danych, czyli w 90% będące elementami List lub słowników, natomiast klasy enumeryczne zawsze oznaczam dużą literką E na początku. Może i nie jest to zgodne z jedną z przyjętych sposobów nazywania, ale i tak znacznie ułatwia korzystanie z klas i zwiększa przejrzystość całego programu, bo wiem gdzie czego szukać.

Widocznie taka specyfika C++/CLI. W C++ rzutowanie w stylu C i static_cast to jest (prawie) to samo. Drugi sposób jest nieco bezpieczniejszy - sprawdzanie zgodności typów odbywa się na poziomie kompilacji.

No... chyba właśnie odwrotnie. Chyba, że w C++ static_cast działą odwrotnie. W C++/CLi (jak się przekonałem) rzutowanie z C jest bezpiecznie, bo w przypadku błędu przy rzutowaniu rzuci wyjątkiem, natomiast static_cast... sam nie wiem, stara się na siłę rzutować, co w przypadku niepowodzenia skutkuje całkowitym zawieszeniem programu, bo rzutowanie okazuje się niemożliwe.

[...]sprawdzanie zgodności typów odbywa się na poziomie kompilacji.

Czyli sprawdził zgodność i ... ? No przecież nie zrzutował. Chyba, że sprawdzanie odbywa się na bardzo podstawowym poziomie (klasa bazowa - klasa pochodna = można zrzutować), a wyniku błędu w kodzie, to sprawdzanie okazało się niewystarczające.
Tu już nie jestem pewien, więc to bardziej takie domysły.

TBase musi być publicznie dziedziczona, ponieważ teraz klasa TDer nie może być traktowana z zewnątrz jako pochodna TBase.

czyli musi być coś takiego ?

KOD cpp:   �  UKRYJ  �

KOD cpp:   �  POKAŻ  �

public ref class TDer : public TBase { ... }

Jeśli tak, to też nie działa. (safe_cast)
A w przypadku dynamic_cast też nie udaje mi się rzutowanie i wyrzuca nullptr, co tak samo skutkuje exception, tylko że nullreference (bo wychodzi kawałek dalej).

[polymorphism]

Wcześniejszego posta nieco zmieniłem, bo wkradł się "drobny" błąd i musiałem go sprostować.

Czyli sprawdził zgodność i ... ?

... i wyrzucił błąd kompilacji.

A propos dynamic_cast. Klasa musi zawierać chociaż jedną metodę wirtualną, żeby ten typ rzutowania działał. Czy ten wymóg w C++\CLI jest konieczny - nie wiem, sprawdź.

A w przypadku dynamic_cast też nie udaje mi się rzutowanie i wyrzuca nullptr

Skompiluj ten kod jako C++:

KOD cpp:   �  UKRYJ  �

KOD cpp:   �  POKAŻ  �

class A { public: virtual void f(){} };
class B: A {};

B foo;
A* p1 = (A*)&foo; //<--- to samo co reinterpret_cast. static_cast nie przejdzie
B* p2 = dynamic_cast<B*>(p1);
       
cout << (p2 ? "good" : "shit") << '\n';
 

i zobacz, co się stanie jeśli zmienisz dziedziczenie na publiczne.

[Slynx]

i zobacz, co się stanie jeśli zmienisz dziedziczenie na publiczne.

Wtedy jest ok, po zmianie na public. Ale w takim wypadku, to błąd leży po stronie języka, albo gdzieś zupełnie indziej, tj. czepiamy się nie tego co trzeba.
Chyba że... klasa musi mieć przynajmniej jedną metodą wirtualną...

No dobra... jeśli dobrze zrozumiałem Twój przykład (a mam nadzieję, że źle) to w zależności od tego czy wyjściowe p2 jest null lub nie wyświetla "true" lub "false".
Tak jak powiedziałem, z public jest wszystko ok, bez zwraca "false".
Więc... przepisałem przykład pod CLI:

KOD cpp:   �  UKRYJ  �

KOD cpp:   �  POKAŻ  �

// B i A ref class.
B^ foo;
A^ p1 = reinterpret_cast<A^ >(foo); //<--- reinterpret_cast, static_cast nie przejdzie
B^ p2 = dynamic_cast<B^>(p1);
                if (p2 == nullptr)
                {
                        MessageBox::Show("nullptr");
                }
                else
                {
                        MessageBox::Show("notnullptr");
                }      
 

I czy jest public czy też nie - zawsze zwraca nullptr.

[polymorphism]

Mnie to nie dziwi, wszak foo jest niezainicjalizowany

[Slynx]

Ok, teraz na poważnie. Sprawdziłem jeszcze kilka rzeczy. Przy safe, dynamic i static cast rzuca błędem InvaidCastOperation. Co do reinterpret Cast. Myślałem, że też nie działa. Nie do końca. Przeleciałem na debuggerze, po całej funkcji. I przy okazji wyłapałem coś jeszcze. Klasa pochodna zawiera dodatkowe pola, które są wpisywane w tej funkcji, ALE przecież obiekt powstaje przez proces rzutowania, wiec konstruktor klasy pochodnej nie został wywołany, tak więc trochę namieszałem, bo ten błąd był spowodowany nullptr, ale nie wykonanym przez błędne rzutowanie, a próbę zapisu danych do niezainicjowanego obiektu listy, 2 linie kodu dalej. Na szybko poprawiłem to, inicjując dane w trakcie. Przy końcówce, czyli dodawaniu właściwego obiektu do bazy (czyli oczekiwane obiektu klasy pochodnej) Visual rzucił błędem (zresztą słusznie)

An unhandled exception of type 'System.ExecutionEngineException' occurred in Unknown Module.

. Przy bliższym przyjrzeniu się obiektowi okazało się, że ma dane niewłaściwie poukładane. Innymi słowy - syf, czemu w sumie się nie dziwię, bo reinterpret_cast nigdy nie darzyłem zaufaniem, zwłaszcza w językach zarządzanych. Więc, w sumie częściowo problem rozwiązany, tzn. Wiadomo co jest nie tak, ale już chyba... skończyły się pomysły, tj. przydałoby się jeszcze jakieś rzutowanie ; p

Masz jeszcze jakiegoś asa w rękawie ?

----
A, i w takim razie miałem rację co do tego static_cast, bo wychodzi na to, że to nie on zablokował działanie aplikacji, a co innego (teraz poszło wszystko normalnie, tzn. błąd wymieniony wyżej;p)

[polymorphism]

W sumie już się trochę pogubiłem w tym wszystkim. Ale jeśli robisz coś takiego:

KOD cpp:   �  UKRYJ  �

KOD cpp:   �  POKAŻ  �

A* base_obj = new A;
B* derived_obj = dynamic_cast<B*>(base_obj);

To się nie dziw, że to nie działa.

Masz jeszcze jakiegoś asa w rękawie ?

Asa żadnego nie mam, ale chciałbym wiedzieć, jak działa mój kod po przenosinach na CLI i poprawnym zainicjalizowaniu uchwytu foo.

[Slynx]

Tam ci chyba brakło nawiasu po new A.
Kod, kod...

KOD cpp:   �  UKRYJ  �

KOD cpp:   �  POKAŻ  �

        public ref class A { public: virtual Void f(){ MessageBox::Show("base class"); } };
        public ref class B: A {public: virtual Void f() override {MessageBox::Show("derived");  }};
 

KOD cpp:   �  UKRYJ  �

KOD cpp:   �  POKAŻ  �

                                B^ foo = gcnew B();
                                A^ p1 = reinterpret_cast<A^ >(foo); //<--- reinterpret_cast, static_cast nie przejdzie
                                B^ p2 = dynamic_cast<B^>(p1);

                               
                if (p2 == nullptr)
                {
                        MessageBox::Show("nullptr");
                }
                else
                {
                        MessageBox::Show("nonnullptr");
                        p2->f();
                }      
 

Przy sprawdzaniu p1, p2 i foo = wszystkie obiekty powodują wyświetlenie "nonnullptr" i "derived";

[polymorphism]

Czyli wygląda na to, że działa (choć trochę dziwne, że przy prywatnym dziedziczeniu).

Tam ci chyba brakło nawiasu po new A.

Niczego mi nie brakowało.

[Slynx]

No niby działa...ale spójrz, przy kompilacji rzuca jeszcze ostrzeżenie:

warning C4669: 'reinterpret_cast' : unsafe conversion: 'test::A' is a managed type object

To działa na tym przykładzie, bo jest prosty, zawiera jedną pustą wirtualną metodę. A przykład, który ja podawałem jest znacznie bardziej złożony i tam się ujawnia to ostrzeżenie, które w tym przypadku nie ma znaczenia. Tak jak mówiłem, dane po rzutowaniu za pomocą reinterpret_cast są błędne lub nie pełne lub po prostu obiekt Klasy pochodnej nie jest obiektem klasy pochodnej, bo nie chce go dodać do listy. Gdyby po rzutowaniu to rzeczywiście był ten obiekt, to nie rzucił by tym wyjątkiem tylko dodał go do listy i przeszedł do kolejnego.