class b{
public:
b(int x){}
};
class a:b{
public:
  a(int x)/*:b(x)*/{}//[C++ Error] Unit1.cpp(49): E2251 Cannot find default constructor to initialize base class 'b'
};
main(){} 

Если надо сначала произвести какие-то действия над х в конструкторе а, и только потом его передать в конструктор b как надо действовать?

Ну, ошибка у тебя - потому что дефолтного конструктора (без параметров) на самом деле нет. Напиши так:

class b
{
public:
    b(int x = 0) {}
};
class a: b
{
public:
    a(int x) {}
};

- ошибки не будет... Но это проблемы-то не решает, дефолтный конструктор предка все равно будет вызван ДО того, как начнет выполняться тело конструктора A. К тому же обрати внимание, у тебя тип наследования не указан, это означает, что будет выбрано наследование частное: class a : b равносильно class a : private b, а не class a : public b. Разницу между общим и необщим наследованием знаешь?

Теперь по твоему вопросу: в общем случае так не делается. Сначала инициализируется базовый класс, и только потом производятся все нужные действия. Можно поподробнее, задача в чем состоит? Наверняка есть более подходящий способ решения.

Есть математическое описание объекта. Нужно сделать его графическое представление. Объект реализуется в своей системе координат. Чтобы сделать поправку при старте хотел обработать входящий параметр. Т.к. фактически мне нужен один метод Draw наследника public не писал.
Разница между общим и необщим наследованием в том, что при общем поля public предка будут видны в наследнике, а иначе нет.
Обойти эту проблему просто: сделать поле с типом "предка", но "наследника" оставить без этого "предка".
А паскаль то позволяет!

Это только часть разницы, причем меньшая. Гораздо интереснее - что

1. Защищенное наследование: все public и protected члены/методы предка в потомке становятся protected-членами/методами.

class A
{
public:
   int x; // Общий член
};

class B : protected A
{
   // Вот тут x уже защищенный, а не общий
};

2. Частное наследование: все public и protected члены/методы предка в потомке становятся private-членами/методами, поэтому

class A
{
public:
    A(int px) : x(px) {}
    int x; // Общий член
};
class B: A  /* или class B : private A */
{
   // В этом классе x уже стал частным
public:
    B(int x) : A(x) {}
};
class C : public B
{
public:
    void test()
    {
        cout << x << endl; // В предке был частным - значит, тут нет доступа... Упс...
    }
};

class Base
{
protected:
    int x;
public:
    Base(int px) : x(px)
    {
        cout << "Base creation : " << x << endl;
    }
};
class Derived : public Base
{
public:
    static Derived processBefore(int x);
private:
    Derived(int x) : Base(x)
    {
        cout << "Derived creation" << endl;
    }
};

inline Derived Derived::processBefore(int x)
{
    cout << "Processing x" << endl; // Обрабатывай
    return Derived(x);
}

int main()
{
    Derived obj = Derived::processBefore(10);
    return 0;
}

Угу?

Опять похоливарить захотелось? Не надо...

Чуть-чуть угу.