简单地说，你不能在c++ 11之前。

c++ 11引入了委托构造函数:

Delegating constructor If the name of the class itself appears as class-or-identifier in the member initializer list, then the list must consist of that one member initializer only; such constructor is known as the delegating constructor, and the constructor selected by the only member of the initializer list is the target constructor In this case, the target constructor is selected by overload resolution and executed first, then the control returns to the delegating constructor and its body is executed. Delegating constructors cannot be recursive. class Foo { public: Foo(char x, int y) {} Foo(int y) : Foo('a', y) {} // Foo(int) delegates to Foo(char,int) };

请注意，委托构造函数是一个全有或全无的提议;如果一个构造函数委托给另一个构造函数，则调用构造函数的初始化列表中不允许有任何其他成员。如果只初始化一次const/reference成员，这是有意义的。

在c++ 11中，一个构造函数可以调用另一个构造函数重载:

class Foo  {
     int d;         
public:
    Foo  (int i) : d(i) {}
    Foo  () : Foo(42) {} //New to C++11
};

此外，成员也可以这样初始化。

class Foo  {
     int d = 5;         
public:
    Foo  (int i) : d(i) {}
};

这样就不需要创建初始化帮助器方法了。并且仍然建议不要在构造函数或析构函数中调用任何虚函数，以避免使用任何可能未初始化的成员。

简单地说，你不能在c++ 11之前。

c++ 11引入了委托构造函数:

Delegating constructor If the name of the class itself appears as class-or-identifier in the member initializer list, then the list must consist of that one member initializer only; such constructor is known as the delegating constructor, and the constructor selected by the only member of the initializer list is the target constructor In this case, the target constructor is selected by overload resolution and executed first, then the control returns to the delegating constructor and its body is executed. Delegating constructors cannot be recursive. class Foo { public: Foo(char x, int y) {} Foo(int y) : Foo('a', y) {} // Foo(int) delegates to Foo(char,int) };

请注意，委托构造函数是一个全有或全无的提议;如果一个构造函数委托给另一个构造函数，则调用构造函数的初始化列表中不允许有任何其他成员。如果只初始化一次const/reference成员，这是有意义的。

是或否，取决于c++的版本。

在c++ 03中，不能从一个构造函数调用另一个构造函数(称为委托构造函数)。

这在c++ 11(又名c++ 0x)中改变了，它增加了对以下语法的支持: (例子摘自维基百科)

class SomeType
{
  int number;
 
public:
  SomeType(int newNumber) : number(newNumber) {}
  SomeType() : SomeType(42) {}
};

另一个还没有展示的选项是将你的类分成两个，在你的原始类周围包装一个轻量级的接口类，以达到你想要的效果:

class Test_Base {
    public Test_Base() {
        DoSomething();
    }
};

class Test : public Test_Base {
    public Test() : Test_Base() {
    }

    public Test(int count) : Test_Base() {
        DoSomethingWithCount(count);
    }
};

如果有许多构造函数必须调用它们的“上一级”对应函数，这可能会很混乱，但对于少数构造函数来说，这应该是可行的。

测试比决定更容易:) 试试这个:

#include <iostream>

class A {
public:
    A( int a) : m_a(a) {
        std::cout << "A::Ctor" << std::endl;    
    }
    ~A() {
        std::cout << "A::dtor" << std::endl;    
    }
public:
    int m_a;
};

class B : public A {
public:
    B( int a, int b) : m_b(b), A(a) {}
public:
    int m_b;
};

int main() {
    B b(9, 6);
    std::cout << "Test constructor delegation a = " << b.m_a << "; b = " << b.m_b << std::endl;    
    return 0;
}

然后用98 std编译: g++ main.cpp -std=c++98 -o test_1

你会看到:

A::Ctor
Test constructor delegation a = 9; b = 6
A::dtor

所以:)