Making parent class members unmodifiable for each derived class

Question

I'm wondering how can I make unmodifiable a parent class member which will be different for each derived class.

My code now assigns its value correctly (depending on the Child class that calls the parent class' constructor), but m_type can be easily modified (in myfunction, for example) and that's what I'd like to avoid.

#include <iostream>

enum Piece_type{    king=1,     queen=3,    rook=3,     bishop=4,   knight=5,   pawn=6};

class Piece
{
    protected:
        Piece_type  m_type; // static Piece_type m_type; <- doesn't work

        Piece(Piece_type ex): m_type(ex) {}
};

class Pawn: public Piece
{
public:
    Pawn():Piece(pawn) {}   // To initialise m_type as pawn for all my Pawn objects

    void myfunction()
    {
        std::cout<<"My piece type is "<< m_type<<std::endl;;
        m_type= knight;   // This is the assignation I want to avoid happening
        std::cout<<"My new piece type i "<<m_type<<std::endl;
    }    
};

My question is related to this one, but inheritance doesn't seem to make possible to declare a static variable and define its value through a member initializer.

I've found how to call the parent/base class constructor from the Child class in this question.

Thanks in advance,

Eduardo

Edit

I've slightly modified it so that not to confuse anyone, because const does work where I said it didn't.

Do you absolutely need this behavior to be validated at compile-time, or are runtime checks acceptable here? — , Jan 03 '17 at 19:19
And why are you trying to express the piece type through both the `m_type` member and the `Pawn` class? Why do you need both? — user2357112, Jan 03 '17 at 19:21
@user2357112 "error: assignment of read-only member 'Piece::m_type' " I have to admit that I have no answer to your second question.. — eduherminio, Jan 03 '17 at 19:24
@Eduardo: That error is **exactly what you asked for**. If you *don't* want an error when you try to modify the thing you want to be unmodifiable, what *do* you want? — user2357112, Jan 03 '17 at 19:25
Beware that const members prevent assignment operators from being generated. — François Andrieux, Jan 03 '17 at 19:28
omg... you absolutely right, @user2357112, I may stop coding for a few hours... — eduherminio, Jan 03 '17 at 19:30

score 3 · Accepted Answer · answered Jan 03 '17 at 19:24

Well, you didn't fall into the usual mistake of trying to use const member variables without a member initializer list, so const is all you need really:

class Piece
{
protected:
    Piece_type const m_type;

    Piece(Piece_type ex) : m_type(ex) { }
};

class Pawn : public Piece
{
public:
    Pawn() : Piece(pawn) { }

    void myfunction()
    {
        // m_type = knight; // Compile-time error
    }    
};

score 3 · Answer 2 · answered Jan 03 '17 at 19:24

3

They only ways to prevent a derived type from modifying it's parent's members is to make those members private or const. Since you can't make the member const the only other way would be to declare the member private and adding a protected accessor method such as :

Piece_type get_type() const 
{
    return m_type;
}

This way, derived classes can call get_type() to know m_type's value but can't access it directly, preventing them from writing to it.

answered Jan 03 '17 at 19:24

François Andrieux

28,148
6
56
87

It seems that `const` finally works, but thank you anyway, I'll take that into account! – eduherminio Jan 03 '17 at 19:38

Making parent class members unmodifiable for each derived class

2 Answers2