Is it good to have a default implementation of all functions of all derived classes

I am trying to write a code model such that there is a base class and two different classes inherit from it, eg:- animal class with the dog and cat class inheriting

Animal* a = new Dog();

playWith(a);

now the playWith function will have animal * as a parameter and should work with both the dog instance or cat instance and will call various functions that might be exclusive to them such as fetch for dog, or climb for cat

Both dog and cat classes will have some same functions which will be declared and defined in the animal class but there are some functions exclusive to only one

I have made the code work by declaring all the exclusive functions in the animal class also with a virtual keyword and an implementation of just throwing an error

And then I have defined the actual implementation inside the derived classes

Now my question is, Is this a good method to define functions, if not can you suggest some alternative

UPDATE:

A minimal example of what I am trying to do is

class Animal {
public:
    void walk(); // all classes are able to call this function and it is inherited from here
    
    virtual void fetch(); // they have an error message such as not implemented
    virtual void climb();
}

class Dog : public Animal {
public    
    void fetch();
}

class Cat : public Animal {
public:
    void climb();
}

class Human{ // complex class with other functions also
    void playWith(Animal* a){ // Please note that this might be part of something else such as another class 
         ...
    }
}

int main(){
    Animal a = new Dog();
    Human h = new Human();
    h->playWith(a);
}

This currently works with the correct function from derived class being called

UPDATE 2:

Currently I cannot declare them as pure virtual functions as the Cat Class does not know how to fetch and the Dog Class does not climb
and If I declare them to be pure virtual then they will need to defined

Base class is meant to capture commonalities. That said, only walk should be declared in Animal. From Animal, you may further derive other kinds of animals with different capabilities like fetch and climb like FetchableAnimal and ClimableAnimal.

Since playWith takes an Animal, it's expected that playWith works with capabilities that all animals share. Since fetch and climb are exclusive to certain animals, it's a design contradiction if you intend to invoke them in playWith(Animal*). You may consider adding playWith(FetchableAnimal*) and playWith(ClimableAnimal*) for such cases.

The bottom line is that base class is supposed to capture feature intersection, not union.

The alternative you are looking for is a pure virtual function.

virtual void playWith(animal *) = 0;

The compiler will force subclasses to create an implementation, much better than a runtime error. Now, there are other parts of this that don't look stylistically correct. If playWith is a method of the Animal class (suggest classes start with a capital letter), then there would be no parameter. If it is supposed to have a parameter, with this playing with the passed in animal, then I would pass by reference: playWith(Animal& a).

Raw pointer use is also discouraged. Can the other animal be created on the stack? If not, you should consider std::unique_ptr or std::shared_ptr.

It's my first typing in stack overflow. After arranging things you are talking, please try the program below I just wrote to see if it can meet what you are thinking.

#include <iostream>

class Animal {
public:
	virtual void played_with() = 0;
};

class Dog : public Animal {
public:
	void played_with() { fetch(); }
private:
	void fetch() { std::cout << "I am fetching.\n"; }
};

class Cat : public Animal {
public:
	void played_with() { climb(); }
private:
	void climb() { std::cout << "I am climbing.\n"; }
};

class Human {
public:
    // Reference is more convenient than pointer here.
	void play_with(Animal& a) { a.played_with(); }
};

int main()
{
    Dog d;
	Cat c;
	Human h;
	h.play_with(d);
	h.play_with(c);
	return 0;
}

I was using Visual Studio 2022. The output is:

I am fetching.
I am climbing.

One aspect of polymorphism in C++ is to declare your functions as virtual and each of your derived classes override them as of their need.
Once you instantiate a Dog object, you call its overriden method, as such preventing cross calling other derived classes methods.

Don't put the exclusive functions as virtual functions in the base animal class. That's a rather bad design.

Instead create new global functions that take either a dog or a cat instance, and use downcasting to cast the animal* pointer to the correct type:

dogOnlyFunction(static_cast<dog*>(a));

While the design, maybe even the requirements and their analysis, seems flawed to begin with, you could solve it with dynamic downcasting, which is checked at runtime:

void playWith(animal* a)
{
    a->walk();  // Common function

    if (auto d = dynamic_cast<dog*>(a); d != nullptr)
    {
        d->fetch();  // Dog specific function
    }
    else if (auto c = dynamic_cast<cat*>(a); c != nullptr)
    {
        c->climb();  // Cat specific function
    }
}

As can be noted from this example, this doesn't scale well when more types are added. So a perhaps better solution is to make a virtual member function playWidth which is overridden in the child classes and calls their specific functions:

struct animal
{
    virtual void playWidth() = 0;
    virtual void walk() = 0;
};

struct dog : public animal
{
    void playWidth() override
    {
        walk();    // Call the common function
        fetch();   // Call the dog specific function
    }

    void walk() override
    {
        // TODO: Walk
    }

    void fetch()
    {
        // TODO: Fetch
    }
};

struct cat : public animal
{
    void playWidth() override
    {
        walk();    // Call the common function
        climb();   // Call the cat specific function
    }

    void walk() override
    {
        // TODO: Walk
    }

    void climb()
    {
        // TODO: Climb
    }
};

In the example above I leave the common walk function as a pure virtual function in the base class, so that all child-classes needs to override it. If not all child-classes should have a walk function, then it could be make class-specific just like fetch and climb.

Now instead of your global void playWith(Animal*) function, just call a->playWidth();