Есть класс интерфейса:

class CMyInterface
{
    int    fd;    // port descriptor    
public:
    CMyInterface(){...}
    virtual         ~CMyInterface(){...}
    virtual bool        ReOpen(void){...}        
    virtual bool         Open( TComParam const &cparam ){...}
    virtual size_t      WriteN( const uint8_t *vptr, size_t len ){...}
    virtual size_t      ReadN( uint8_t *vptr, size_t n ){...}
        virtual bool        IsValid(){...}    
    virtual void        Close(){...}
    virtual int         SetIrqChar(char IrqChr){...}
    virtual int         GetNextPacket(char *txt_buff, size_t len ) = 0;//!!!Нет реализации!!!
};

и два наследника:

class CMyClass1: public CMyInterface
{
public:
    CMyClass1( );
    ~CMyClass1( );
    bool        ReOpen(void){... }            
    bool         Open( TComParam const &cparam ){...};
    size_t         WriteN( const uint8_t *vptr, size_t len )
        {   
            size_t sz = CMyInterface::WriteN(vptr, len);
            ...
        }   
    size_t         ReadN(uint8_t *vptr, size_t n )
        {
            return CMyInterface::ReadN(vptr, n);  
        }
    int        ReadBlock( uint8_t *buf, int len );
    int         SetIrqChar(char IrqChr)
        {
        return CMyInterface::SetIrqChar(IrqChr);
        }
    int         GetNextPacket(char *txt_buff, size_t len )
        {
             ......
        }
    
        bool             IsValid()
        {
             return CMyInterface::IsValid();
             ...
        }

    void        Close( ){    CMyInterface::Close();   };
    inline void FlushIO( ){...};
};

class CMyClass2: public CMyInterface
{
public:
    CMyClass2( );
    ~CMyClass2( );
    bool        ReOpen(void){... }            
    bool         Open( TComParam const &cparam ){...};
    size_t         WriteN( const uint8_t *vptr, size_t len )
        {   
            size_t sz = CMyInterface::WriteN(vptr, len);
            ...
        }   
    size_t         ReadN(uint8_t *vptr, size_t n )
        {
            CMyInterface::ReadN(vptr, n);  
            ......................
        }
    int        ReadBlock( uint8_t *buf, int len );
    int         SetIrqChar(char IrqChr)
        {
        return CMyInterface::SetIrqChar(IrqChr);
        }
    int         GetNextPacket(char *txt_buff, size_t len )
        {
            ......
        }
    
        bool             IsValid()
        {
            return CMyInterface::IsValid();
            ...
        }

    void        Close( )
        { 
               ...............   
               CMyInterface::Close();   
        };
};

Разница между CMyClass1 и CMyClass2 небольшая.

создание объектов разных типов происходит следующим образом:

CMyInterface*      my_ptr; //глобальный указатель

        if(true == one_condition)
    {
        my_ptr = new CMyClass1 ;
    }
    else
    {
        my_ptr = new CMyClass2;    
    }

Дальше я работаю с указателем my_ptr, абстрагируясь от конкретного типа(CMyClass1 или CMyClass2).
В случае когда one_condition == true всё ОК. Когда one_condition == false при обращении к
my_ptr->GetNextPacket программа падает с сообщением segmentation fault.

Вопросы:
1. почему программа падает?
2. как реализовать подобный механизм?

Здравствуйте, Аноним, Вы писали:

А>1. почему программа падает?

смотрите в отладчике

Здравствуйте, Аноним, Вы писали:

А>Вопросы:
А>1. почему программа падает?
А>2. как реализовать подобный механизм?
Ну механизм работает

#include <iostream>

class A
 {
    A(const A &); // нельзя
    A &operator=(const A &); // нельзя
  public:
    explicit A(){}
    virtual void func() = 0;
    virtual ~A(){}
 };

class A1 : public A
 {
    A1(const A1 &); // нельзя
    A1 &operator=(const A1 &); // нельзя
  public:
    explicit A1(){}
    void func()
    {
      std::cout << "A1::func" << std::endl;
    }
    virtual ~A1(){}
 };

class A2 : public  A
 {
    A2(const A2 &); // нельзя
    A2 &operator=(const A2 &); // нельзя
  public:
    explicit A2(){}
    void func()
    {
      std::cout << "A2::func" << std::endl;
    }
    virtual ~A2(){}
 };

void main()
{
  A* a1,*a2;
  a1=new A1();
  a2=new A2();
  a1->func();
  a2->func();
  delete a1;
  delete a2;
  a1=new A2();
  a2=new A1();
  a1->func();
  a2->func();
  delete a1;
  delete a2;

}

Вывод

A1::func
A2::func
A2::func
A1::func

Почему падает — в отладчике смотрим...