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

SVisor <svisor@xxxxxxxxx> · Tue, 07 Sep 2004 18:34:58 +0200

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();
}