🚀 go-pugleaf

Franky Braem writes:

> Hallo Ik heb een klasse die erft van een template met zichzelf als 1
> van de arguments. Deze template heeft een statische member. Ik
> probeer deze statische member te initialiseren via de klasse (en
> niet via de template)

> Wanneer ik compileer met VC, dan werkt alles perfect. Compileer ik
> met gcc (van MingW) dan krijg ik volgende foutmelding:

> ISO C++ does not permit 'T<A, B>::var' to be defined as 'A::var'

> A erft van T<A,B> en var is een statische member van T. Kan ik gcc
> deze fout laten negeren? Of moet ik een workaround gebruiken?

> Waarom gebruik ik niet T<A,B>::var ? Omdat de code gegenereert wordt
> via een macro en die kan (mag) ik niet wijzigen.

kan je niet eens wat (relevante) code posten, want het is me niet
geheel duidelijk.. 
sjuus
domi

-- 
Tell the truth or trump--but get the trick.
		-- Mark Twain, "Pudd'nhead Wilson's Calendar"

Franky Braem wrote on 10-12-2002 15:26:

> Hallo
> 
> Ik heb een klasse die erft van een template met zichzelf als 1 van de
> arguments. Deze template heeft een statische member. Ik probeer deze
> statische member te initialiseren via de klasse (en niet via de template)
> 
> Wanneer ik compileer met VC, dan werkt alles perfect. Compileer ik met gcc
> (van MingW) dan krijg ik volgende foutmelding:
> 
> ISO C++ does not permit 'T<A, B>::var' to be defined as 'A::var'
> 
> A erft van T<A,B> en var is een statische member van T. Kan ik gcc deze fout
> laten negeren? Of moet ik een workaround gebruiken?
> 
> Waarom gebruik ik niet T<A,B>::var ? Omdat de code gegenereert wordt via een
> macro en die kan (mag) ik niet wijzigen.
> 
> Franky.

Een static member variabele van een basisklasse gebruiken in de namespace
van de afgeleide klasse is toegelaten. Het is redelijk gevaarlijk en het is
altijd beter van je data zelf private of protected te houden in de klasse
waarin ze gedefinieerd is.

Gcc op MacOSX compileert de volgende code trouwens zonder problemen:

/////////////////////////////////////////

#include <stdio.h>

template <class X>
class T {
public:
static int var;
};

template <class X> int T<X>::var = 6;

class B : public T<B> {
};

int main() {
    printf ("%d\n",B::var);
}

/////////////////////////////////////////

Een mogelijke workaround zou zijn (als je gcc dit toelaat) om een statische
functie in B te definieren die var teruggeeft.

/////////////////////////////////////////

#include <stdio.h>

template <class X>
class T {
public:
    static int var;
};

template <class X> 
int T<X>::var = 6;

class B : public T<B> {
public:
    static int GetVar() {
        return T<B>::var;
    }
};

int main() {
    printf ("%d\n",B::GetVar());
}

/////////////////////////////////////////

Als dat niet gaat, laat gcc dan gewoon de fout negeren.

Greetz,
Jacko

"Dominique Devriese" <dominique.devriese@student.kuleuven.ac.be> wrote in
message news:87lm2ykkpg.fsf@appel.kotnet.org...
> Franky Braem writes:
>
> > Hallo Ik heb een klasse die erft van een template met zichzelf als 1
> > van de arguments. Deze template heeft een statische member. Ik
> > probeer deze statische member te initialiseren via de klasse (en
> > niet via de template)
>
> > Wanneer ik compileer met VC, dan werkt alles perfect. Compileer ik
> > met gcc (van MingW) dan krijg ik volgende foutmelding:
>
> > ISO C++ does not permit 'T<A, B>::var' to be defined as 'A::var'
>
> > A erft van T<A,B> en var is een statische member van T. Kan ik gcc
> > deze fout laten negeren? Of moet ik een workaround gebruiken?
>
> > Waarom gebruik ik niet T<A,B>::var ? Omdat de code gegenereert wordt
> > via een macro en die kan (mag) ik niet wijzigen.
>
> kan je niet eens wat (relevante) code posten, want het is me niet
> geheel duidelijk..
> sjuus
> domi
>

class A : public T<A>
{
};

template<class T1>
class T
{
public:
  static int var;
};

Het volgende werkt in VC++ :

int A::var = 0;

maar werkt niet met gcc.

Klasse A is gedefinieerd volgens het "Curiously Recursive Template Pattern".

Franky Braem writes:

> class A : public T<A> { };

> template<class T1> class T { public:
>   static int var;
> };

> Het volgende werkt in VC++ :

> int A::var = 0;

> maar werkt niet met gcc.

> Klasse A is gedefinieerd volgens het "Curiously Recursive Template
> Pattern".

template<class T1>
class T
{
public:
  static int var;
};

template<class T1> int T<T1>::var;

class A : public T<A>
{
};

int main()
{
  A::var = 0;
}


deze code werkt in gcc.

Ik weet niet wat er juist mis is gegaan (misschien de foutmelding
posten ? ) maar deze twee dingen ben je mss vergeten:
Een statische variabele moet je buiten de klasse-definitie nog apart
definieren: daarvoor dient de lijn "template<class T1> int T<T1>::var;".
en je moet de template-klasse natuurlijk definieren voor je A ervan
laat erven, maar dat zul je wel weten, veronderstel ik..
sjuus
domi

-- 
Nothing so needs reforming as other people's habits.
		-- Mark Twain, "Pudd'nhead Wilson's Calendar"

Franky Braem wrote:

> class A : public T<A>
> {
> };
> 
> template<class T1>
> class T
> {
> public:
>   static int var;
> };
> 
> Het volgende werkt in VC++ :
> 
> int A::var = 0;
> 
> maar werkt niet met gcc.

Lijkt me logisch, dat is de definitie
bij een eerdere declaratie van :

class A : public T<A>
{
   static int var;
};

Voor de definitie van een static geldt hetzelfde
als voor member functions van T<A>, die zou je
ook niet gaan definieren als void A::f () { }

Dat de baseclass een template is en ook nog eens
A als template parameter heeft maakt niet zoveel
uit denk ik :)

imho 2c etc.
Bert

Franky Braem wrote:

(snip)

> int A::var = 0;
> 
> maar werkt niet met gcc.

Whoeps:

<sessie>
itsme@stoned:~$ cat test.cpp 
template<class T1>
class T
{
public:
  static int var;
};

class A: public T<A>
{
};

int A::var = 0;

int main()
{
        A a;
        a.var = 6;
}
itsme@stoned:~$ g++-3.2 -Wall -ansi -pedantic test.cpp 
test.cpp:12: warning: ISO C++ does not permit `T<A>::var' to be defined as 
`A::
   var'
itsme@stoned:~$ g++-3.2 -W -Wall -ansi -pedantic test.cpp 
test.cpp:12: warning: ISO C++ does not permit `T<A>::var' to be defined as 
`A::
   var'
test.cpp: In function `int main()':
test.cpp:18: Internal compiler error in make_decl_rtl, at varasm.c:835
Please submit a full bug report,
with preprocessed source if appropriate.
See <URL:http://www.gnu.org/software/gcc/bugs.html> for instructions.
itsme@stoned:~$ 
</sessie>

Owla zeg, die -W veroorzaakt een internal compiler error. Ben aan het 
zoeken of dit nog het geval is met de nieuwste snapshot als ik die in mijn 
totale onkennis gecompileerd krijg :-).

(Moest iemand zeker zijn dat dit bekend is, of de laatste gcc snapshot 
hebben en merken dat het er niet meer inzit: replyen aub :-).

En ik maar denken dat alleen MSVC++ problemen had met ingewikkelde 
template-constructies (terugdenkende aan een project dat ik net voor school 
heb gemaakt ;-).

-- 
Nicolas Barbier

"Bert Peers" <piek@ab.oo> wrote in message
news:VKqJ9.15$Ih.2944@news.chello.be...
> Franky Braem wrote:
>
> > class A : public T<A>
> > {
> > };
> >
> > template<class T1>
> > class T
> > {
> > public:
> >   static int var;
> > };
> >
> > Het volgende werkt in VC++ :
> >
> > int A::var = 0;
> >
> > maar werkt niet met gcc.
>
> Lijkt me logisch, dat is de definitie
> bij een eerdere declaratie van :
>
> class A : public T<A>
> {
>    static int var;
> };
>
> Voor de definitie van een static geldt hetzelfde
> als voor member functions van T<A>, die zou je
> ook niet gaan definieren als void A::f () { }
>
> Dat de baseclass een template is en ook nog eens
> A als template parameter heeft maakt niet zoveel
> uit denk ik :)

Ik denk van wel. Hierdoor krijgt A een eigen static member var. Stel dat B
ook derived via dezelfde methode dan zal B::var en A::var niet hetzelfde
zijn.

>
> imho 2c etc.
> Bert
>

Franky Braem writes:

> "Bert Peers" <piek@ab.oo> wrote in message
> news:VKqJ9.15$Ih.2944@news.chello.be...
>> Franky Braem wrote:
>>
>> > class A : public T<A> { };
>> >
>> > template<class T1> class T { public:
>> >   static int var;
>> > };
>> >
>> > Het volgende werkt in VC++ :
>> >
>> > int A::var = 0;
>> >
>> > maar werkt niet met gcc.
>>
>> Lijkt me logisch, dat is de definitie bij een eerdere declaratie
>> van :
>>
>> class A : public T<A> { static int var; };
>>
>> Voor de definitie van een static geldt hetzelfde als voor member
>> functions van T<A>, die zou je ook niet gaan definieren als void
>> A::f () { }
>>
>> Dat de baseclass een template is en ook nog eens A als template
>> parameter heeft maakt niet zoveel uit denk ik :)

> Ik denk van wel. Hierdoor krijgt A een eigen static member var. Stel
> dat B ook derived via dezelfde methode dan zal B::var en A::var niet
> hetzelfde zijn.

dat is sowieso niet het geval.
als je een template hebt:
template<class T>
class Template
{
}

dan moet je in je hoofd houden dat Template<A> en Template<B> helemaal
_niks_ met elkaar te maken hebben.  Je moet doen alsof je ze elk apart
had geschreven...
sjuus
domi


-- 
If you stand on your head, you will get footprints in your hair.

Franky Braem wrote:

> class A : public T<A>
> {
> };
> 
> template<class T1>
> class T
> {
> public:
>   static int var;
> };
> 
> Het volgende werkt in VC++ :
> 
> int A::var = 0;
> 
> maar werkt niet met gcc.

Dit heeft niets met templates te maken: hetzelfde gebeurt als je van T een 
gewone class maakt (en is IMHO ook totaal logisch). Dat MSVC++ dit toelaat 
is eigenlijk zelfs totaal abnormaal. Ik ben niet een van de "gelukkigen" 
die de code van MSVC++ mag inzien, maar het lijkt me dus moeilijker om dit 
toe te laten dan om een fout te geven (_Wil_ Microsoft misschien dat er 
totale rotzooi wordt geschreven die als "C++-code" moet doorgaan?).

-- 
Nicolas Barbier

Nicolas Barbier wrote:

> Owla zeg, die -W veroorzaakt een internal compiler error. Ben aan het
> zoeken of dit nog het geval is met de nieuwste snapshot als ik die in mijn
> totale onkennis gecompileerd krijg :-).

Ok, never mind, is opgelost in een snapshot van gcc 3.3. Of in feite geeft 
hij een of andere foutmelding die ik niet begrijp maar er is dus blijkbaar 
toch aan gewerkt :-).

<sessie>
itsme@stoned:~$ ./gcc_test/bin/g++ --version                         
g++ (GCC) 3.3 20021209 (experimental)
Copyright (C) 2002 Free Software Foundation, Inc.
This is free software; see the source for copying conditions.  There is NO
warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

itsme@stoned:~$ cat test.cpp 
template<class T1>
class T
{
public:
  static int var;
};

class A: public T<A>
{
};

int A::var = 0;

int main()
{
        A a;
        a.var = 6;
}
itsme@stoned:~$ ./gcc_test/bin/g++ -Wall -ansi -pedantic test.cpp 
test.cpp:12: warning: ISO C++ does not permit `T<A>::var' to be defined as 
`A::
   var'
test.cpp: In function `int main()':
test.cpp:16: error: `A A::a' is not a static member of `class A'
test.cpp:17: error: `a' undeclared (first use this function)
test.cpp:17: error: (Each undeclared identifier is reported only once for 
each 
   function it appears in.)
itsme@stoned:~$ ./gcc_test/bin/g++ -W -Wall -ansi -pedantic test.cpp 
test.cpp:12: warning: ISO C++ does not permit `T<A>::var' to be defined as 
`A::
   var'
test.cpp: In function `int main()':
test.cpp:16: error: `A A::a' is not a static member of `class A'
test.cpp:17: error: `a' undeclared (first use this function)
test.cpp:17: error: (Each undeclared identifier is reported only once for 
each 
   function it appears in.)
itsme@stoned:~$ 
</sessie>

"test.cpp:16: error: `A A::a' is not a static member of `class A'"

Deze foutmelding snap ik dus totaal niet.. anyone? Nuja, ze treedt niet op 
als ik die foute regel vervang door de juiste (A vervangen door T<A>).

-- 
Nicolas Barbier

Nicolas Barbier wrote on 10-12-2002 21:58:

> Nicolas Barbier wrote:
> 
>> Owla zeg, die -W veroorzaakt een internal compiler error. Ben aan het
>> zoeken of dit nog het geval is met de nieuwste snapshot als ik die in mijn
>> totale onkennis gecompileerd krijg :-).
> 
> Ok, never mind, is opgelost in een snapshot van gcc 3.3. Of in feite geeft
> hij een of andere foutmelding die ik niet begrijp maar er is dus blijkbaar
> toch aan gewerkt :-).
> 
> <sessie>
> itsme@stoned:~$ ./gcc_test/bin/g++ --version
> g++ (GCC) 3.3 20021209 (experimental)
> Copyright (C) 2002 Free Software Foundation, Inc.
> This is free software; see the source for copying conditions.  There is NO
> warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
> 
> itsme@stoned:~$ cat test.cpp
> template<class T1>
> class T
> {
> public:
> static int var;
> };
> 
> class A: public T<A>
> {
> };
> 
> int A::var = 0;
> 
> int main()
> {
>       A a;
>       a.var = 6;
> }

Er zit een fout in je code. Je kan een statische variabele enkel oproepen
als A::var, niet als member variabele van een instantie...

Dominique Devriese wrote on 10-12-2002 20:44:

> Franky Braem writes:
> 
>> "Bert Peers" <piek@ab.oo> wrote in message
>> news:VKqJ9.15$Ih.2944@news.chello.be...
>>> Franky Braem wrote:
>>> 
>>>> class A : public T<A> { };
>>>> 
>>>> template<class T1> class T { public:
>>>>   static int var;
>>>> };
>>>> 
>>>> Het volgende werkt in VC++ :
>>>> 
>>>> int A::var = 0;
>>>> 
>>>> maar werkt niet met gcc.
>>> 
>>> Lijkt me logisch, dat is de definitie bij een eerdere declaratie
>>> van :
>>> 
>>> class A : public T<A> { static int var; };
>>> 
> 
> dat is sowieso niet het geval.
> als je een template hebt:
> template<class T>
> class Template
> {
> }
> 
> dan moet je in je hoofd houden dat Template<A> en Template<B> helemaal
> _niks_ met elkaar te maken hebben.  Je moet doen alsof je ze elk apart
> had geschreven...
> sjuus

Meer zelfs, als je 

static int var; 

Als member van A gaat definieren, dan zijn T<A>::var en A::var verschillende
statische variabelen die elkaar niet beinvloeden.

Er is ook niets  terug te vinden in de standaard over het oproepen van deze
statische variabele. Misschien in de ARM, maar die heb ik hier net niet
liggen.

Jacko

Franky Braem wrote on 10-12-2002 20:21:

> "Bert Peers" <piek@ab.oo> wrote in message
> news:VKqJ9.15$Ih.2944@news.chello.be...
>> Franky Braem wrote:
>> 
>>> class A : public T<A>
>>> {
>>> };
>>> 
>>> template<class T1>
>>> class T
>>> {
>>> public:
>>>   static int var;
>>> };
>>> 
>>> Het volgende werkt in VC++ :
>>> 
>>> int A::var = 0;
>>> 
>>> maar werkt niet met gcc.
>> 
>> Lijkt me logisch, dat is de definitie
>> bij een eerdere declaratie van :
>> 
>> class A : public T<A>
>> {
>>    static int var;
>> };
>> 
>> Voor de definitie van een static geldt hetzelfde
>> als voor member functions van T<A>, die zou je
>> ook niet gaan definieren als void A::f () { }
>> 
>> Dat de baseclass een template is en ook nog eens
>> A als template parameter heeft maakt niet zoveel
>> uit denk ik :)
> 
> Ik denk van wel. Hierdoor krijgt A een eigen static member var. Stel dat B
> ook derived via dezelfde methode dan zal B::var en A::var niet hetzelfde
> zijn.

Ik denk dat Bert bedoelt dat je var eerst moet definieren als:

template <class T1> int T<T1>::var = 0;

In plaats van:

int A::var = 0;

Er is een verschil tussen de definitie van de statische variabele en de
access van een statische variabele. Na de definitie, mag je normaal zonder
problemen A::var gebruiken voor T<A>::var.

Jack D wrote:

> Er zit een fout in je code. Je kan een statische variabele enkel oproepen
> als A::var, niet als member variabele van een instantie...

Heeft altijd al gemogen dacht ik, en blijkbaar geeft GCC er in ANSI-modus 
ook geen fouten op:

<sessie>
itsme@stoned:~$ cat test.cpp 
#include <iostream>

class A
{
public:
        static int var;
};

int A::var = 0;

int main()
{
        A a;
        a.var = 6;
        std::cout << A::var << std::endl;
}
itsme@stoned:~$ g++-3.2 -W -Wall -ansi -pedantic test.cpp 
itsme@stoned:~$ ./a.out 
6
itsme@stoned:~$ 
</sessie>

Mijn punt was dat, hoe fout de code ook is, GCC nooit een "internal 
compiler error" hoort te geven. En dat is dan blijkbaar ook opgelost in die 
nieuwere versie.

-- 
Nicolas Barbier

Nicolas Barbier wrote on 11-12-2002 14:02:

> Jack D wrote:
> 
>> Er zit een fout in je code. Je kan een statische variabele enkel oproepen
>> als A::var, niet als member variabele van een instantie...
> 
> Heeft altijd al gemogen dacht ik, en blijkbaar geeft GCC er in ANSI-modus
> ook geen fouten op:

Beu, inderdaad... Was verward door een fout die ik gemaakt had bij het
uitproberen.

class A {
    static int var;
};

int A::var = 0;

int main() {
    cout << A.var;
}           ^^^^^
       Nie goe dadde...

Jack D wrote:

>>int main()
>>{
>>      A a;
>>      a.var = 6;
>>}
> 
> Er zit een fout in je code. Je kan een statische variabele enkel oproepen
> als A::var, niet als member variabele van een instantie...
> 

Hm, dat lijkt me een te krasse uitspraak. 9.4.2 :

A static member s of class X may be referred to using the qualified-id
expression X::s; it is not necessary to use the class member access
syntax to refer to a static member.

Daar staat dus wel 'may', niet must.  'Not necessary', maar het mag.

Bert

Bert Peers wrote:

>> Er zit een fout in je code. Je kan een statische variabele enkel oproepen
>> als A::var, niet als member variabele van een instantie...
>>
> Hm, dat lijkt me een te krasse uitspraak. 9.4.2 :
[...]
> Bert


Mental note to self : de hele thread lezen vooraleer te replyen :)
Nevermind dus :)


Bert