struct someParamA
{  ...  };

class someClassA
{
   virtual void Func(someParamA *pParam) {  ...  } //в ф-ии используется поля из someParamA
};


struct someParamB: public someParamA
{  ...  }; //добавлены новые поля

class someClassB: public someClassA
{
   virtual void Func(someParamA *pParam) {  ...  } //в ф-ии используется поля из someParamB
};

A>struct someParamA
A>{  ...  };
A>struct someParamB: public someParamA
A>{  ...  }; //добавлены новые поля
A>
A>class someClassA
A>{
A>   virtual void Func(someParamA *pParam) {  ...  } //в ф-ии используется поля из someParamA
A>};
A>class someClassB: public someClassA
A>{
A>   virtual void Func(someParamA *pParam) {  ...  } //в ф-ии используется поля из someParamB
A>};
A>

class someClassB: public someClassA
{
  virtual void Func(someParamA *pParamA) 
  { //в ф-ии используется поля из someParamB
    if ( someParamB* pParamB= dynamic_cast<someParamB*>(pParamA) )
    {
       // использование pParamB
    }
  } 
};

class someClassA;
class someClassB;

struct someParamA
{
  virtual void Visit( someClassA* );
  virtual void Visit( someClassB* );
};
struct someParamB: public someParamA
{  
  virtual void Visit( someClassA* );
  virtual void Visit( someClassB* );
}; //добавлены новые поля

class someClassA
{ 
public:
   void Func(someParamA* pA ) { pA->Visit(this); }
   void FuncA(someParamA *pParam) {} //в ф-ии используется поля из someParamA
};
class someClassB: public someClassA
{
public:
   void FuncB(someParamB *pParam) {} //в ф-ии используется поля из someParamB
};

void someParamA::Visit( someClassA* pA ) { pA->FuncA(this); }
void someParamA::Visit( someClassB* pB ) { /* do nothing*/ }

void someParamB::Visit( someClassA* pA ) { /* do nothing*/ }
void someParamB::Visit( someClassB* pB ) { pB->FuncB(this); }

If the type of expression is a base class of the type of type-id, a run-time check is made to see if expression actually points to a complete object of the type of type-id. If this is true, the result is a pointer to a complete object of the type of type-id. For example:

class B { ... };
class D : public B { ... };

void f()
{
   B* pb = new D;                     // unclear but ok
   B* pb2 = new B;

   D* pd = dynamic_cast<D*>(pb);      // ok: pb actually points to a D
   ...
   D* pd2 = dynamic_cast<D*>(pb2);   // pb2 points to a B not a D
                                    // cast was bad so pd2 == NULL

A>struct someParamA
A>{  ...  };

A>class someClassA
A>{
A>   virtual void Func(someParamA *pParam) {  ...  } //в ф-ии используется поля из someParamA
A>};


A>struct someParamB: public someParamA
A>{  ...  }; //добавлены новые поля

A>class someClassB: public someClassA
A>{
A>   virtual void Func(someParamA *pParam) {  ...  } //в ф-ии используется поля из someParamB
A>};
A>

struct someParamA {
  size_t my_size;
  ...  
};

void someClassA::Func(someParamA *pParam) {
  if (pParam->my_size < sizeof(someParamA))
    throw "Opanki!";
  ....
}

void someClassB::Func(someParamA *pParam) {
  if (pParam->my_size < sizeof(someParamB))
    throw "Opanki!";
  ....
}