niszczenie "obiektów" klasy wewnątrz konstruktora

[polymorphism]

Słowo klucz: polimorfizm.

p.s. to delete wewnątrz konstruktora jest zbędne. Przecież wszystkie zmienne host_n są niezainicjalizowane.

[Slynx]

To chyba bardziej metody wirtualne... choć sam nie wiem... strasznie ciężko to zrozumieć :/ Czytam, czytam, niby wszystko oczywiste, ale i tak nic nie rozumiem ; p
Spróbuję jeszcze raz przejrzeć.

[polymorphism]

To chyba bardziej metody wirtualne... choć sam nie wiem...

Dokładnie, nie wiesz Czytaj, czytaj...

[Slynx]

Ok, do czegoś doszedłem
Więc, klasa MailBox mogłaby się stać klasą bazową dla wszystkich hostów. Ta klasa bazowa mogłaby posiadać jedną funkcję wirtualną do przedefiniowania przez konstruktor wywoływanego hosta (jeśli wywołany konstruktor hosta1 to ten ustawia w tej funkcji "wpis na siebie"), tylko jeszcze nie wiem co ten "wpis na siebie" miałby oznaczać ; p

---
3 minuty później....
---
Nie mogę tego znaleźć, ale jeśli można w przedefiniowanej funkcji wirtualnej zmienić również typ zwracanej wartości, mógłbym wtedy wrzucić return obiekt_klasy_hosta.
Ale...(chwila, bo to wydaje się zbyt oczywiste;p, muszę sprawdzić jeszcze raz;p)

Klasa bazowa musi mieć jakieś specjalne właściwości ? Przy próbie przypisania (public ref class host_1 : //przestrzeń_nazw//MailBox) wyrzuca mi błąd, że nie wie co to MailBox (w include jest).

To tak... teoretycznie.
Ciężko tu coś zrobić teoretycznie, bo wszystkie przykłady są w c++, a próba przepisania do C++/cli czegoś czego kompletnie się nie zna...:/
//
ok, wiem o co chodzi z tą klasą bazową. A raczej, to nie jej wina (przynajmniej jak na razie), a wzajemnego dodawania się klas (tak, dokładnie, deklaracja zapowiadająca, ale nie wiem gdzie to wstawić, trochę dużo tych includów:/)

///
albo w ogóle nie definiować metody wirtualnej, stworzyć metodę czysto wirtualną. W VC++ było chyba do tego jakieś słówko kluczowe. wait sec

// Może jutro do tego wrócę. Nie mam już pomysłów i to nawet nie z tym całym polimorfizmem, ale z deklaracjami zapowiadającymi. Tak kombinowałem, że miałem "internal compiler error". Tylko ja umiem zawiesić Visuala manipulacjami funkcjami wirtualnymi + deklaracje zapowiadające; p

[Cyfrowy Baron]

Nie mogę tego znaleźć, ale jeśli można w przedefiniowanej funkcji wirtualnej zmienić również typ zwracanej wartości,

Jeżeli chcesz by funkcja zwracała wartości różnego typu, to stwórz funkcję ogólną. Coś w tym stylu:

KOD cpp:   �  UKRYJ  �

KOD cpp:   �  POKAŻ  �

template <class T> T FUNKCJA(T x, T y)
{
 return x + y;
}

Taka funkcja zwraca typ zależny od użytych argumentów. Jeżeli argumenty będą typu String to ten typ funkcja zwróci, a jeżeli typu integer to zwróci typ int.

[Slynx]

A jaka jest zasada jeśli chodzi o te deklaracje zapowiadające ? Na dwóch inludach to był żaden problem, ale ja mam ich 20 i gdy dojdzie klasa wirtualna zaczną się nawzajem "wykorzystywać". Natomiast ja nie wiem gdzie wstawiać te deklaracje, co przed czym :/

[Cyfrowy Baron]

Deklaracja wygląda tak samo jak dla zwykłej funkcji:

Plik nagłówkowy np. Unit1.h

KOD cpp:   �  UKRYJ  �

KOD cpp:   �  POKAŻ  �

public:
        template <class T> T __fastcall Funkcja(T x, T y);

Plik źródłowy np. Unit1.cpp

KOD cpp:   �  UKRYJ  �

KOD cpp:   �  POKAŻ  �

//---------------------------------------------------------------------------
void __fastcall TForm1::Button5Click(TObject *Sender)
{
 String a = "a";
 String b = "b";

 Edit1->Text = Funkcja(a, b);
}
//---------------------------------------------------------------------------
template <class T> T __fastcall TForm1::Funkcja(T x, T y)
{
  return x + y;
}
//---------------------------------------------------------------------------

Z tym, że trzeba być tutaj bardzo precyzyjnym, gdyż np. takie wywołanie funkcji nie zadziała:

KOD cpp:   �  UKRYJ  �

KOD cpp:   �  POKAŻ  �

 Edit1->Text = Funkcja("a", "b");

Ponieważ w tym przypadku argumenty "a", "b" mogą być zarówno typu String jak i typu char, a jak wiadomo char nie można dodawać, tak jak to robi funkcja. Zauważ, że jeszcze na etapie kompilacji sprawdzane jest co przekazujesz do funkcji i czy można wykonać działania na przekazywanych zmiennych pomimo, że funkcja nie ma jasno zdefiniowanego typu argumentów, to jednak nie są dozwolone argumenty na których nie można wykonać działania określonego w ciele funkcji.

[polymorphism]

Baron, sprawdź, czy skompiluje Ci się próba wywołania metody Funkcja spoza pliku Unit1.cpp

Ponieważ w tym przypadku argumenty "a", "b" mogą być zarówno typu String jak i typu char, a jak wiadomo char nie można dodawać, tak jak to robi funkcja.

I dlatego w C++ jest coś takiego jak specjalizacja szablonów. Czyli dla Twojego przykładu tworzymy specjalną wersję szablonu dla c-stringów:

KOD cpp:   �  UKRYJ  �

KOD cpp:   �  POKAŻ  �

public:
        template <class T> T __fastcall Funkcja(T x, T y);

...

template <> char* __fastcall TForm1::Funkcja<char*>(char* x, char* y);

...

/* cpp */
template <> char* __fastcall TForm1::Funkcja<char*>(char* x, char* y)
{
        /* tu odpowiednie operacje sumowania dwóch c-stringów */
}

[Slynx]

No tak tak, ale ja pytałem o deklaracje zapowiadające. Polymorphism wie o co mi chodzi. Jak się zorientować, gdzie powinna być deklaracja tak by działało ? Jaka jest zasada, skąd wiesz która deklaracja przed którą ?

Ponieważ w tym przypadku argumenty "a", "b" mogą być zarówno typu String jak i typu char, a jak wiadomo char nie można dodawać, tak jak to robi funkcja.

A można to po prostu zrzutować do stringa ? Czy nie skompiluje, np.

KOD cpp:   �  UKRYJ  �

KOD cpp:   �  POKAŻ  �

Edit1->Text = (string&)Funkcja("a", "b");
 

[Cyfrowy Baron]

Baron, sprawdź, czy skompiluje Ci się próba wywołania metody Funkcja spoza pliku Unit1.cpp

Działa tylko trzeba ją odpowiednio zaadresować np w Unit2.cpp:

KOD cpp:   �  UKRYJ  �

KOD cpp:   �  POKAŻ  �

void __fastcall TForm2::Button1Click(TObject *Sender)
{
 String a = "a";
 String b = "b";

 Edit1->Text= Form1->Funkcja(a, b);
}

I dlatego w C++ jest coś takiego jak specjalizacja szablonów. Czyli dla Twojego przykładu tworzymy specjalną wersję szablonu dla c-stringów:

Ale w ten sposób tworzymy dodatkową funkcję, równie dobrze mógłbym wykorzystać przeciążenie funkcji.

---

No tak tak, ale ja pytałem o deklaracje zapowiadające.

A jak postępujesz z deklaracjami dla zwykłych funkcji?!

[Slynx]

Ok, ale wy tu sobie gadu gadu, a wróćmy do metod wirtualnych. So,

KOD cpp:   �  UKRYJ  �

KOD cpp:   �  POKAŻ  �

#pragma once
#include "virt.h"
using namespace System::Windows::Forms;
ref class xx : public virt
{
public:
        xx(void){};
        virtual void virt::Do()
        {
                MessageBox::Show("xx");
        }
};
ref class xy: public virt
{
public:
        xy(void){};
        virtual void virt::Do()
        {
                MessageBox::Show("xy");
        }
}

 

i klasa wirtualna, bazowa.

KOD cpp:   �  UKRYJ  �

KOD cpp:   �  POKAŻ  �

#pragma once

using namespace System::Windows::Forms;
public ref class virt
{
public:
        virt(void){};
        virtual void virt::Do(){MessageBox::Show("something");}
};

 

error C3254: 'xx' : class contains explicit override 'Do' but does not derive from an interface that contains the function declaration

Jeśli dobrze zrozumiałem to... mam dobrze. "Do" ma swoją deklarację (definicję) jako metody wirtualnej.

// dobra. chyba wiem gdzie popełniam błędy, bo to wszystko nie tak powinno wyglądać. Muszę jeszcze coś sprawdzić.
Dobra, jednego jestem pewien ;p

There are four classes given on this example. Shape is a base class and Rect1, Circle and Triangle are the classes derived from the base class Shape. The base class Shape* is used to access all three dervied class functions. It is called Polymorphism.

// 5 minut później...

CUD !
Sprawiłem, że metody czysto wirtualne kompilują się pod C++/CLI ;p
Klasa abstrakcyjna (jak moje pomysły;p)

KOD cpp:   �  UKRYJ  �

KOD cpp:   �  POKAŻ  �

#pragma once

using namespace System::Windows::Forms;
using namespace System;
public ref class virt abstract
{
public:
        virt(void) {};
        ~virt(void) {};
        virtual void Do() =0;

};
 

2 klasy korzystające z klasy bazowej

KOD cpp:   �  UKRYJ  �

KOD cpp:   �  POKAŻ  �

#pragma once
#include "virt.h"
using namespace System::Windows::Forms;
public ref class xx : public virt
{
public:
        xx(void){};
        virtual void Do() override
        {
                MessageBox::Show("xx");
        }
};
public ref class xy: public virt
{
public:
        xy(void){};
        virtual void Do() override
        {
                MessageBox::Show("xy");
        }
};
 

KOD cpp:   �  UKRYJ  �

KOD cpp:   �  POKAŻ  �

virt^ z = gcnew xx;
// lub virt^ z = gcnew xy;
z->Do(); // w zależności od... nie-konstruktora wypisze "xx" albo "xy"
 

Ok, ale mam jeden problem, która będzie widzoczny przy próbie przeniesienia tego w "rzeczywistość".
Klasy hostów wymagają użycia konstruktora. Każdy obiekt wirtualnej klasy (virt) musi pracować na własnym obiekcie hosta (xx, xy);
Można coś z tym zrobić ?

[polymorphism]

Działa tylko trzeba ją odpowiednio zaadresować np w Unit2.cpp:

Hmm, generalnie nie powinno się skompilować. Metody szablonowe powinny być implementowane jako inline, czyli wewnątrz definicji klasy, lub po prostu w tym samym pliku (albo kilku nagłówkach). Wyjątkiem są pełne specjalizacje metod/funkcji.

Ale w ten sposób tworzymy dodatkową funkcję, równie dobrze mógłbym wykorzystać przeciążenie funkcji.

Owszem, mechanizm jest bardzo podobny, choć specjalizacja nie ogranicza się tylko do metod, lecz także do klas.

[polymorphism]

KOD cpp:   �  UKRYJ  �

KOD cpp:   �  POKAŻ  �

ref class xy: public virt
{
public:

        virtual void virt::Do() //<-- a to 'virt' to po co tutaj?
        ...
}

To samo w klasie virt.

[Slynx]

Poprawiłem post wyżej( podpisuje, bo możesz nie zauważyć)

[polymorphism]

Nie rozumiem pytania.