Inherited member( void )const - const to be or not to be

[SVisor]

Hi and thanks for the reply, but I do not agree...

...
> Don't use _CONST ... that's a reserved symbol.

Well that was news. Anyway it was just "dummy" code.

...
> All symbols starting with underscore followed by a capital letter are 
> reserved.  All symbols with two underscores in a row anywhere are reserved.

name__more is not reserved. __name is reserved. Usage of _Name is not 
recomended, but what I know not reserved. At least thats what I have 
been taught. No one has _ever_ shown proof of anything else (heck no one 
has shown me proof of what Ive learned, I just have accepted it ;-). Do 
you have any link to a list of which combinations are reserved and which 
are not?

> I've fixed your code, works now just fine.  Compiled either way.

NO! You _broke_ it! Now you return a pointer to constant, and thats 
_NOT_ what I wanted. I wanted to hint the compiler that a function does 
not change members, but I can still change members (and call non 
constant member-functions) using the returned pointer (and its legal 
C++). The question was more about cast from "this", like this:

virtual CProvider* getProvider( void )const{ return (CProvider*)this; }

It will compile and provide sane working code, but its C (not C++) 
styled. And the cast is not _safe_: The code would compile even if the 
class would not inherit from CProvider.

...
> BTW:  using the -DCONST=const is preferred.  So much so, that you should 

I do not agree as thats not portable across all compilers. While my 
construct is (well 99.9% of them at least). The code was just dummy code 
to show a point, and make it easy to test. You usually know if something 
is const or not :-).

// Jarmo

-- 

> just have const in the code.  Const correctness should be worked in from 
> the beginning.
> 
> HTH,
> --Eljay
> 
> - - - - - - - - -
> // Compile #1:  g++ -DCONST=const foo.cpp
> // Compile #2:  g++ -DCONST= foo.cpp
> #include <cstdio>
> 
> class CProvider
> {
> protected:
>     const char* str;
> public:
>     CProvider(const char* s)
>     : str(s)
>     {
>         printf("CProvider(%s)\n",str);
>     }
> 
>     void echo() CONST
>     {
>         printf("CProvider(%s)::echo()\n", str);
>     }
> };
> 
> 
> class CAbstract
> {
> public:
>     CAbstract()
>     {
>         printf("CAbstract\n");
>     }
> 
>     virtual ~CAbstract()
>     { }
> 
>     virtual CProvider CONST* getProvider() CONST = 0;
> };
> 
> 
> class CAllocated : public CAbstract
> {
> protected:
>     CProvider* ptr;
> 
> public:
>     CAllocated()
>     {
>         printf("CAllocated\n");
>         ptr = new CProvider("Allocated");
>     }
> 
>     virtual CProvider CONST* getProvider() CONST
>     {
>         return ptr;
>     }
> };
> 
> 
> class CInherited : public CAbstract, public CProvider
> {
> public:
>     CInherited()
>     : CProvider("Inherited")
>     {
>         printf("CInherited\n");
>     }
> 
>     virtual CProvider CONST* getProvider() CONST
>     {
>         return this;
>     }
> };
> 
> 
> int main()
> {
>     CAllocated tmp1;
>     CInherited tmp2;
> 
>     tmp1.getProvider()->echo();
>     tmp2.getProvider()->echo();
> 
>     CAbstract* pTmp1 = &tmp1;
>     CAbstract* pTmp2 = &tmp2;
>     pTmp1->getProvider()->echo();
>     pTmp2->getProvider()->echo();
> }
> 
>