"Hans Willumsen" <SPAMMh_will@mail.tele.dk> wrote in message
news:b0ttas$2k2n$1@news.cybercity.dk...
[8<8<8<]
> jeg forventer at når jeg laver en klasse af CChild så vil CParent
> constructoren køre og kalde CChilds udgave af SpecifikInitialisering og
> ikke sin egen. I praksis sker det ikke.
Det er i overensstemmelse med C++ Standarden.
Når virtuelle metoder kaldes fra constructor/destructor vil den højest kunne
kalde metoder i den klasse, der er ved at blive oprettet/nedlagt selvom det
endelige objekt er endnu mere specialiseret.
Det er for at undgå at virtuelle metoder kan tilgå datamedlemmer i den mest
afledte klasse, som endnu ikke er oprettet.
Det er overranskende første gang man støder på det, men egentlig meget
forståeligt, når man tænker lidt mere over det.
[8<8<8<]
> ....<5 minuter senere>... hmm.. kan det have noget at gøre med at CChild
> delen ikke er lavet endnu i det CParent constructoren kalder
> SpecifikInitialisering? Det kunne måske tænkes.
Ja.
> Hvis det er tilfældet, hvordan kommer man så mest elegant ud af det
> problem?
Der findes nok ikke en universel løsning på dit spørgsmål.
Du er nok nødt til at gå tilbage og overveje hvad det er for et problem du
_egentlig_ er i gang med at løse.
Der kan være flere scenarier, f.eks.:
1. den afledte klasse skal give noget initialiserings information til
basis-klassen.
2. alle objekter af en given type skal gøre noget bestemt, når de er
oprettet
3. basis-klassen afhænger af statisk information fra den afledte klasse
Ad 1.
I det tilfælde at basis-klassen har brug for noget initialiserings
information for at kunne gennemføre sin constructor, kan den stille sådan et
krav ved enten at tage den information som et constructor argument (runtime
dynamisk) eller et template argument (runtime statisk, compiletime
dynamisk).
<code>
class window
{
public:
window(int x_pos_arg, int y_pos_arg, unsigned width_arg, unsigned
height_arg)
{
}
private:
virtual void paint() const = 0;
};
template <bool horizontal>
class scroll_bar : public window
{
public:
enum { HORIZONTAL_HEIGHT = 10,
VERTICAL_WIDTH = 10
};
scroll_bar(int x_pos_arg, int y_pos_arg, unsigned width_or_height_arg,
int min_scroll_pos_arg, int max_scroll_pos_arg, int scroll_pos_arg)
:
window(x_pos_arg, y_pos_arg,
horizontal ? width_or_height_arg : VERTICAL_WIDTH,
horizontal ? HORIZONTAL_HEIGHT : width_or_height_arg),
min_scroll_pos_(min_scroll_pos_arg),
max_scroll_pos_(max_scroll_pos_arg),
scroll_pos_(scroll_pos_arg)
{}
private:
virtual void paint() const
{
if(horizontal) {
// ...
}
else {
// ...
}
}
private:
int min_scroll_pos_;
int max_scroll_pos_;
int scroll_pos_;
};
typedef scroll_bar<true> horizontal_scroll_bar;
typedef scroll_bar<false> vertical_scroll_bar;
int main()
{
horizontal_scroll_bar sb(10, 10, 20, 0, 100, 0);
}
</code>
Ad 2.
Hvis alle objeter skal gøre noget bestemt men typeafhængigt når de bliver
oprettet, vil det være nærliggende at lægge det i basis-klassens
constructor:
<code>
class window
{
public:
window(int x_pos_arg, int y_pos_arg, unsigned width_arg, unsigned
height_arg)
{
paint();
}
private:
virtual void paint() const = 0;
};
template <bool horizontal>
class scroll_bar : public window
{
public:
enum { HORIZONTAL_HEIGHT = 10,
VERTICAL_WIDTH = 10
};
scroll_bar(int x_pos_arg, int y_pos_arg, unsigned width_or_height_arg,
int min_scroll_pos_arg, int max_scroll_pos_arg, int scroll_pos_arg)
:
window(x_pos_arg, y_pos_arg,
horizontal ? width_or_height_arg : VERTICAL_WIDTH,
horizontal ? HORIZONTAL_HEIGHT : width_or_height_arg),
min_scroll_pos_(min_scroll_pos_arg),
max_scroll_pos_(max_scroll_pos_arg),
scroll_pos_(scroll_pos_arg)
{}
private:
virtual void paint() const
{
if(horizontal) {
// ...
}
else {
// ...
}
}
private:
int min_scroll_pos_;
int max_scroll_pos_;
int scroll_pos_;
};
typedef scroll_bar<true> horizontal_scroll_bar;
typedef scroll_bar<false> vertical_scroll_bar;
int main()
{
horizontal_scroll_bar sb(10, 10, 20,
0, 100, 0);
}
</code>
Problemet er blot - som du har konstateret - at det kan man ikke, fordi
objektet er ikke f.eks. en scroll_bar endnu, og kan derfor ikke tegne sig
rigtigt.
Ud over at bruge en factory, som Igor V. Rafienko og Mads Orbesen Troest har
foreslået, kan man lave en template støtteklasse til basis-klassen der
sikrer at alt er oprettet inden den virtuelle metode kaldes:
<code>
class window
{
public:
window(int x_pos_arg, int y_pos_arg, unsigned width_arg, unsigned
height_arg)
{
}
protected:
virtual void paint() const = 0;
};
template <typename T>
class window_final : public T
{
public:
window_final() :
T()
{
paint();
}
template <typename Arg1T>
window_final(Arg1T arg1) :
T(arg1)
{
paint();
}
// ...
template <typename Arg1T, typename Arg2T, typename Arg3T, typename Arg4T,
typename Arg5T, typename Arg6T>
window_final(Arg1T arg1, Arg2T arg2, Arg3T arg3, Arg4T arg4, Arg5T arg5,
Arg6T arg6) :
T(arg1, arg2, arg3, arg4, arg5, arg6)
{
paint();
}
};
template <bool horizontal>
class scroll_bar_impl : public window
{
public:
enum { HORIZONTAL_HEIGHT = 10,
VERTICAL_WIDTH = 10
};
scroll_bar_impl(int x_pos_arg, int y_pos_arg, unsigned
width_or_height_arg,
int min_scroll_pos_arg, int max_scroll_pos_arg, int scroll_pos_arg)
:
window(x_pos_arg, y_pos_arg,
horizontal ? width_or_height_arg : VERTICAL_WIDTH,
horizontal ? HORIZONTAL_HEIGHT : width_or_height_arg),
min_scroll_pos_(min_scroll_pos_arg),
max_scroll_pos_(max_scroll_pos_arg),
scroll_pos_(scroll_pos_arg)
{}
protected:
virtual void paint() const
{
if(horizontal) {
// ...
}
else {
// ...
}
}
private:
int min_scroll_pos_;
int max_scroll_pos_;
int scroll_pos_;
};
typedef window_final<scroll_bar_impl<true > > horizontal_scroll_bar;
typedef window_final<scroll_bar_impl<false> > vertical_scroll_bar;
int main()
{
horizontal_scroll_bar sb(10, 10, 20,
0, 100, 0);
}
</code>
Ad 3.
Hvis basis-klassen har brug for information fra den afledte klasse, som
_kun_ afhænger af den afledte klasses type (og altså ikke state, som endnu
ikke er initialiseret), kan man statisk føde den information op til
basis-klassen via templates ved hjælp af "curiously recurring template
patterns" (C++ Report, Februar 1995).
Bemærk den _væsentlige_ forskel i strukturen i brugen af templates i
"window_final" i foregående eksempel.
<code>
class window
{
protected:
window(int x_pos_arg, int y_pos_arg, unsigned width_arg, unsigned
height_arg) :
x_pos_(x_pos_arg),
y_pos_(y_pos_arg),
width_(width_arg),
height_(height_arg)
{
}
virtual ~window() {}
protected:
virtual void paint() const = 0;
private:
int x_pos_;
int y_pos_;
unsigned width_;
unsigned height_;
};
template <class T>
class type_window : public window
{
public:
type_window(int x_pos_arg, int y_pos_arg) :
window(x_pos_arg, y_pos_arg, T::default_width(), T::default_height())
{}
type_window(int x_pos_arg, int y_pos_arg, unsigned width_arg, unsigned
height_arg) :
window(x_pos_arg, y_pos_arg, width_arg, height_arg) {}
};
template <bool horizontal>
class scroll_bar : public type_window<scroll_bar<horizontal> >
{
public:
enum { HORIZONTAL_HEIGHT = 10,
VERTICAL_WIDTH = 10
};
scroll_bar(int x_pos_arg, int y_pos_arg,
int min_scroll_pos_arg, int max_scroll_pos_arg, int scroll_pos_arg)
:
type_window<scroll_bar>(x_pos_arg, y_pos_arg),
min_scroll_pos_(min_scroll_pos_arg),
max_scroll_pos_(max_scroll_pos_arg),
scroll_pos_(scroll_pos_arg)
{}
static unsigned default_width()
{ return VERTICAL_WIDTH; }
static unsigned default_height()
{ return HORIZONTAL_HEIGHT; }
protected:
virtual void paint() const
{
if(horizontal) {
// ...
}
else {
// ...
}
}
private:
int min_scroll_pos_;
int max_scroll_pos_;
int scroll_pos_;
};
typedef scroll_bar<true> horizontal_scroll_bar;
typedef scroll_bar<false> vertical_scroll_bar;
int main()
{
horizontal_scroll_bar sb(10, 10,
0, 100, 0);
}
</code>
> Jeg vil gerne kalde den specifikke initialisering i constructoren... er
jeg
> virkelig nødt til at kalde den explicit i CChilds constructor?
constructoren er jo netop lavet til at initialisere objektet, så det lyder
meget fornuftigt.
CParent constructoren har ansvaret for at initialisere CParent delen, og
tilsvarende har CChild constructoren ansvaret for at initialisere CChild
delen.
Hvorfor ikke bare skrive koden direkte i constructoren for hver af de 2
klasser ?
Somme tider har hver klasse flere constructorer, og de deler noget fælles
initialisering som kan være bekvemt at lægge ud i en separat metode - men
det kan man jo bare gøre i hver klasse:
<pseudo C++ code>
class base
{
public:
base(arg_type1)
{ init(); }
base(arg_type2)
{ init(); }
private:
void init()
{ ... }
}:
class derived : public base
{
public:
derived(arg_type1 arg) :
base(arg) { init(); }
derived(arg_type2 arg) :
base(arg) { init(); }
private:
void init()
{ .... }
};
</pseudo C++ code>
Venlig hilsen
Mogens Hansen