Remove code duplication for virtual class members in C++ inheritance

Here's one solution using an intermediate layer of another abstract base class:

class Base12 : public Base {
protected: 
    int commonFuncStuffA() {
       // Commonly used stuff 
    }

    int commonFuncStuffB() {
    }
};

class der1: public Base12
{
public:
    virtual int func1() {
        n = commonFuncStuffA();
    }
    virtual int func2() {
        n = somethingElse;
    }
};

class der2: public Base12
{
public:
    virtual int func1() {
        n = commonFuncStuffA();
    }
    virtual int func2() {
        n = commonFuncStuffB();
    }
};

What I'd do for real production code design looks a bit different though.

1. Declare an interface for the pure virtual functions

   struct IMyInterface {
       virtual int func1() = 0;
       virtual int func2() = 0;
       virtual ~IMyInterface {}
   };
   

2. Provide a abstract base class with the commonly used data members and functions

   class BaseImpl : public IMyInterface {
   protected: 
       int n;
       int commonFuncStuffA() {
           // Commonly used stuff 
       }
   
       int commonFuncStuffB() {
           // Commonly used stuff 
       }
   };
   

3. Provide implementations of the interface in the finally derived classes

   class der1: public BaseImpl {
   public:
       virtual int func1() {
           n = commonFuncStuffA();
       }
       virtual int func2() {
           n = somethingElse;
       }
   };
   
   
   class der2: public BaseImpl {
   public:
       virtual int func1() {
           n = commonFuncStuffA();
       }
       virtual int func2() {
           n = commonFuncStuffB();
       }
   };
   
   class der3: public IMyInterface {
   public:
       virtual int func1() {
           // Some completely different implementation of the interface
       }
       virtual int func2() {
           // Some completely different implementation of the interface
       }
   };
   
   class der4: public IMyInterface {
   public:
       virtual int func1() {
           // Some completely different implementation of the interface
       }
       virtual int func2() {
           // Some completely different implementation of the interface
       }
   };
   

Option 1

You may consider using your most common implementation in the Base class. The main feature or drawback of this method is that the base class would no longer be abstract. If this is a problem, go to option 2.

Maybe you can even cope with differences in the derived classes by using the template method pattern to extract the differences in protected virtual functions invoked by the template method.

In anyway, for derived classes that need a completely different appoach, you'd just override the the Base class' method.

class Base
{
public:
  virtual int func1();
  virtual int func2()=0;
protected:
  virtual void f1_specific_part1()=0;
  virtual void f1_specific_part2()=0; 
  int n;
};
int Base::func1() { // common skeleton of the algorithm
     ...  
     f1_specific_part1(); 
     ... 
     f1_specific_part2(); 
     ...
}     

class Der1: public Base
{ 
protected:
 void f1_specific_part1() override;  // Implements the specific variation
 virtual void f1_specific_part2() override;       
};

Option 2

You may consider to factorize the common code of the derived classes into a protected method of the Base class.

The override of the pure virtual function would then just call the base class protected common function (for der1 and der2) or just use their own implementation that is completely different (for der3 and der4).

class Base
{
public:
  virtual int func1()=0;
  virtual int func2()=0;
protected:
  int common_part1_funct1(); // implements some common parts 
  int common_part2_funct1();
  int n;
};

class Der1: public Base
{
...
  int func1() override { 
     common_part1_funct1();
     ...
     common_part2_funct1(); 
     ... 
  }
};

Option 3 ?

Important remark: My answer assumes that there are many commonalities between most of the derived classes. However if you have only a small subset of derived classes that share some commonalities, then the answer of Evg would be would be more appropriate.

The idea with Base12 is:

struct Base {
    virtual int func1() = 0;
    virtual int func2() = 0;
};

struct Base12 : Base {
protected:
    int func12();
};

struct Der1: public Base12 {
    virtual int func1() {
        return func12();
    virtual int func2() {
        return func12();
};

struct Der2: public Base12 {
    virtual int func1() {
        return func12();
    virtual int func2() {
        return func12();
};