losing const

[Scott MacMaster]

I'm working on some code for a library. I want to code it as correctly as possible to reduse the likelihood that someone will accidently write bad code and mess up internal data structures. Anyone here is a simplification of the code I have.

class A
{
public:
	int someValue;
};

class B
{
	public:
		B(A value)
			: a(value)
		{ }
		
		void SetValue(int value)
		{
			a.someValue = value;
		}
		
	private:
		A a;
};

class C
{
	public:
		C()
			: a()
		{}
		
		B const GetA() const
		{
			B const b(a);
			return b;
		}
		
	private:
		A a;
};


int main(void)
{
	C const c;
	B b(c.GetA());	// this shouldn't work
	b.SetValue(10);	// nor this and C is now changed even though it's const and no typecasting was done
	
	return 0;
}

Where am I losing const which would allow the code in main() to compile? Also, any suggestions on how to force B to have to be B const for it to compile?


Thanks,
Scott MacMaster

[NMTop40]

Because const is a type qualifier. Your code is actually calling:

B::B( const B& b );

in this line

B b(c.GetA());	// this shouldn't work

If you want the B in main to be non-modifiable declare it thus:

const B b( c.GetA() );

(you are using const after the type which though legal is unconventional).

If you want to have a "const class", i.e. a version whereby you can never call the non-const methods, you should split B into two classes.

class BConst
{
public:
   BConst( A aIn ) : a( aIn ) {}

   virtual ~BConst() {};
   int getA() const { return a.SomeValue(); }

protected:

   A a;
};

class B : public BConst
{
 public:
    B( A aIn ) : BConst( aIn ) {}
    
    void setA( int i ) { a.someValue = i; }
};

class C
{
  public:
    const BConst getA() const; // etc
};

Your function will return a BConst on which nobody can call setA() because it's not a member of the class. This is how you might also implement read-only in idl (interface definition language) where const methods do not exist.

[matthias_k]

you are using const after the type which though legal is unconventional

I've never seen that before, does 'const B b;' mean something different than 'B const b;' ?

[NMTop40]

It surprises me that you haven't seen it, I think it's generally more conventional. They mean the same thing.

[Kheun]

I've never seen that before, does 'const B b;' mean something different than 'B const b;' ?

There is only different for pointer.

const char *p1 = "1st";     // pointer to char that is constant
char * const p2 = "2nd";    // const pointer to char
char const *p3 = "1st";     // same as p1.

p1[0] = '2';   // Compiler error.
p1 = "3rd";    // Ok.
p2 = "3rd";    // Compiler error.

[Scott MacMaster]

Because const is a type qualifier. Your code is actually calling:

B::B( const B& b );

in this line

B b(c.GetA());	// this shouldn't work

Ok, something did some correct about it. This explains why.

If you want the B in main to be non-modifiable declare it thus:

const B b( c.GetA() );

Yea, but I want callers of my code not to have to do that. So 'A' can't be modified. My code actually uses templates. If I could typecast TemplateClass<type> to TemplateClass<type const> I wouldn't have this problem with trying to find a way to do this. Any chance you know why that typecast isn't allowed?

If you want to have a "const class", i.e. a version whereby you can never call the non-const methods, you should split B into two classes.

After spending several hours trying things yesterday, that's what I ended up doing.



Thanks,
Scott MacMaster

[Scott MacMaster]

I've never seen that before, does 'const B b;' mean something different than 'B const b;' ?

No, it this case it doesn't. Some people think it unconventional but thatsonly because they learned c/c++ that way. Having const afterward is more natural for reading c/c++. If you have const to the right of the const component of the type you can read the type from right to left. Makes reading more complex types easier.

Examples:
B const variable; // variable is a constant object of type B
B const * const variable; // variable is a constant pointer to a constant object of type B


Later,
Scott MacMaster

[Guysl]

Yea, but I want callers of my code not to have to do that. So 'A' can't be modified. My code actually uses templates. If I could typecast TemplateClass<type> to TemplateClass<type const> I wouldn't have this problem with trying to find a way to do this. Any chance you know why that typecast isn't allowed?

I believe that the following thread might interest you. The relevant part is on page 2 of the thread:

http://www.codeguru.com/forum/showth...ighlight=const