Calling parent function from another function using child C++

No, the parent classes public functions are callable from the child object. However, the prototype of the function is

void Node::addChildNode(Node node);

So it's taking a Node object & not a Cube object. So your compiler cannot find a function which takes a Cube object & hence the error.

The fix is to use a pointer to Node or reference to Node while declaring/defining the function.

So you function should be

void addChildNode(Node & node);

In which case, the Node object can be passed to the function & the compiler will find it.

Even better would be to have

// if you aren't looking to modify the passed object inside addChildNode
void addChildNode(const Node & node); 

The following is fine & hence the function will work

Cube b;   
Node &a = b;

or

Node * pn = &b;

The derived classes should be able to see the addChildNode function if you keep the signature of the function aligns. This is not a big issue. However, there are a few more "serious" issues with your code:

1. You need to make the base class' destructor virtual to avoid some undefined behaviors.

2. You have to design the ownership of nodes carefully. I guess you want the Node class to own and manage its children nodes. That means function addChildNode actually takes the ownership of the passed in node object, and it should also be deleted during destruction.

3. In function addCubes(), there is a loop that keeps calling addChildNode function but passes the local variable Cube c; which will be out of scope and destroyed after the loop. Thus, the parent object mainCube will holds pointers to already destroyed objects, and it will cause a crash.

After fixing all these issues, your code looks like this:

class Node
{
public:
    Node() {};
    virtual ~Node() {
        for(auto n: childNodes) delete n;
    };

    void setParentNode(Node* parent) {this->parentNode = parent;}
    Node* getParentNode() {return this->parentNode;}

    std::vector<Node*> getChildNodes(){return this->childNodes;}

    void addChildNode(Node* node) {
        childNodes.push_back(node);
    };
    void removeNode();

private:
    std::vector<Node*> childNodes;
    Node* parentNode = nullptr;
};

class Cube : public Node
{
public:
    Cube() {};
};

void addCubes(){
    Cube mainCube;
    for(int i = 0; i < 10; i++){
        Cube *c = new Cube();
        mainCube.addChildNode(c);
    }
}

It is preferred to use smart pointers to manage memory, and the code is more elegant and easier to read, and it makes it harder to make mistakes :-).

#include <memory>

class Node
{
public:
    Node() {};
    virtual ~Node() {};

    void setParentNode(Node* parent) {this->parentNode = parent;}
    Node* getParentNode() {return this->parentNode;}

    std::vector<std::shared_ptr<Node>>& getChildNodes(){return this->childNodes;}

    void addChildNode(std::shared_ptr<Node> node) {
        childNodes.push_back(std::move(node));
    };
    void removeNode();

private:
    // childNodes own elements in it, they will be deleted automatically.
    std::vector<std::shared_ptr<Node>> childNodes;
    Node* parentNode = nullptr;
};
class Cube: public Node
{
public:
    Cube() {};
};
void addCubes(){
    Cube mainCube;
    for(int i = 0; i < 10; i++){
        auto c = std::make_unique<Cube>();
        mainCube.addChildNode(std::move(c));
    }
}

Assuming that you have shared the entire implementation of your code. You have not defined the body of the function addChildNode, similar to setParentNode etc. You need to do something like childNodes.push_back(node); inside that function.

Note: It is also necessary that you pass the input to addChildNode as shown in the answer by @user93353. Also, define childNodes as std::vector<Node *> in order to avoid object slicing.