Инициализация полей класса при наследовании

class A{
public:
    A() {}
protected:
    const int   field;
};

class B: public A{
public:
    B() {}
    
};

class B: public A{
public:
    B(): field(1000) {}
    
};

field=1000;

B() : A(1255)

#include <iostream>
#include "Some1.h"
using namespace std;
 
class SecretBase
{
protected:
    const int m_code = 17;
public:
    SecretBase( const int am )
        : m_code( am )
    {
    }
};
 
class Secret : public SecretBase
{
public:
    Secret() : SecretBase( 55 )
    {
    }
};
 
 
class CustumSecret : public Secret
{
private:
    int m_code;
 
public:
    CustumSecret()
        : m_code( Secret::m_code + 1000)
    {
    }
    int getSecret() const
    {
        return m_code;
    }
};
 
 
int main()
{
    CustumSecret secret;
    cout << secret.getSecret() << endl;
}

#include <iostream>
#include "Some1.h"
using namespace std;
 
 
class SomeVar
{
public:
    SomeVar( int f )
    {
        cout << "I am some var with " << f << endl;
    }
};
 
class MustBeInited
{
private:
    int m_x;
public:
    MustBeInited()
    {
        cout << "Dont inited" << endl;
    }
    MustBeInited( int x ) 
        : m_x(x)
    {
        cout << "Already inited with " << x << endl;
    }
};
 
 
class A
{
protected:
    const MustBeInited m_some;
};
 
class B : public A
{
private:
    SomeVar m_some;
 
public:
    B() : m_some( 14 )
    {
 
    }
};
 
int main()
{
    {
        B b;
    }
    cout << "Hello world" << endl;
}

class A{
public:
    A(){
        var=var_init;   // Тут нужно, чтобы 'var_init' уже была проинициализирована наследником
    }
protected:
    int     var_init;
private:
    int     var;
};

class A
{
protected:
    int _q;
public:
    A()
    {
    }
};
 
class B : public A
{
protected:
    int _t;
public:
    B() : _t(_q) 
        // если тут _q в подвешенном состоянии был бы, то вообще беда бы была!!!!!
        // Но память под _q выделена и он проинициализирован A()
    {
    }
};

class A{
public:
    A(){
        var=var_init;   // Тут нужно, чтобы 'var_init' уже была проинициализирована наследником
    }
protected:
    int     var_init;
private:
    int     var=0;      // Если наследника нет, то иним нулём
};

A() : var(0)
{}

class A
{
protected:
    int _q;
public:
    A()
    {
    }
};
 
class B : public A
{
protected:
    int _t;
public:
    B() : _t(_q) 
        // если тут _q в подвешенном состоянии был бы, то вообще беда бы была!!!!!
        // Но память под _q выделена и он проинициализирован A()
    {
    }
};

    B() : _t(_q)

    B() : _q(_t)