Is there a way to modify the private variables of a child class using an inherited method in C++?

Question

I have a class Child that inherits from a class Parent. They both have a private instance variable named a. The parent class has a method to change the a variable.

Parent.h

#pragma once
#include <iostream>
class Parent {
public:
    Parent() {}
    ~Parent() {}

    virtual void changeA() {
        a++;
        std::cout << "Parent a: " << a << std::endl;
    }

private:
    int a = 0;
};

Child.h

#pragma once

#include "Parent.h"

class Child : public Parent {
public:
    Child() {}
    ~Child() {}

    void changeA() {
        Parent::changeA();
        std::cout << "Child a: " << a << std::endl;
    }

private:
    int a = 0;
};

main.cpp

#include "Child.h"
#include "Parent.h"
#include <iostream>

int main() {
    Parent parent = Parent();
    Child child = Child();

    parent.changeA();
    std::cout << "---" << std::endl;
    child.changeA();

    return 0;
}

stdout

Parent a: 1
---
Parent a: 1
Child a: 0

It seems as if the Child object also has a copy of the Parent object. How do I get the Parent's changeA method to change the Child's a instance variable?

Clarification: I need this because I have a parent class Entity with two children Enemy and Player, and both classes need to use the same init method inherited from Entity.

Answer 1

The parent class knows nothing of any child. It can define a virtual method, and the child can override this method like that:

class Child : public Parent {
    void changeA() override {
        // Here the Child::a will be changed:
        ++a;
        std::cout << "Child a: " << a << std::endl;
    }

private:
    int a = 0;
};

The override (or final) is an optional specifier, but it is the best practice to specify one.

There is however a way to let the parent know the child. That is called Curiously Recurring Template Pattern (CRTP):

template<typename Child>
class Parent {
public:
    virtual void changeA() {
        // Here the Child::a is changed:
        static_cast<Child*>(this)->a++;
        std::cout << "Parent a: " << a << std::endl;
    }

private:
    int a = 0;
};

class Child : public Parent<Child> {
public:
    void changeA() override {
        Parent::changeA();
        std::cout << "Child a: " << a << std::endl;
    }

private:
    int a = 0;
};

The code above would not compile however because the Child::a is private, and the Parent<Child> has no access to this member. You may either make it public or make the Parent a friend:

class Child : public Parent<Child> {
public:
    void changeA() override {
        Parent::changeA();
        std::cout << "Child a: " << a << std::endl;
    }

private:
    int a = 0;
    friend class Parent<Child>;
};

Overall I don't understand your intention, and the code is error prone. I guess there are better ways to solve your actual problem.

Update: another way to achieve the behavior is to store a reference in the Parent. You don't even need to make the method virtual in this case:

class Parent {
public:
    Parent(int &a) : a(a) {}
    void changeA() {
        a++;
        std::cout << "Parent a: " << a << std::endl;
    }

private:
    int &a;
};

class Child : public Parent {
    Child() : Parent(a) {}

private:
    int a = 0;
};

In this case only one instance of the integer field is allocated, and the Parent uses the same data the Child stores.

Answer 2

Make Parent::changeA a virtual function and add code to Child::changeA to modify Child::a. Quick example:

#include <iostream>

class Parent {
public:
    virtual ~Parent() {} // almost always want a virtual destructor
                         // Don't need it here, but if you find yourself 
                         // having to delete a Child through a Parent 
                         // pointer this is a must.

    virtual void changeA() { // virtual function at runtime the derived version, 
                             // if one exists, will be called instead of 
                             // Parent::changeA
        a++;
        std::cout << "Parent a: " << a << std::endl;
    }

private:
    int a = 0;
};


class Child : public Parent {
public:

    void changeA() override { // will be called in place of Parent::changeA 
                              // the override keyword will cause a compiler 
                              // error if no override takes place. Zero 
                              // runtime cost and saves debugging. Winning.
        Parent::changeA(); // modifies Parent::a
        a++; // modifies its Child::a
        std::cout << "Child a: " << a << std::endl;
    }

private:
    int a = 0;
};

int main() {
    Parent parent;
    Child child;

    parent.changeA();
    std::cout << "---" << std::endl;
    child.changeA();

    return 0;
}

Documentation for override.