Могу ли я вызвать конструктор из другого конструктора (выполнить цепочку конструкторов) в C ++?

Проще говоря, вы не можете до C ++ 11.

C ++ 11 вводит делегирующие конструкторы:

Делегирующий конструктор

Если имя самого класса отображается как класс или идентификатор в список инициализаторов членов, тогда список должен состоять из этого одного члена только инициализатор; такой конструктор известен как делегирующий конструктор, и конструктор, выбранный единственным членом список инициализаторов - это целевой конструктор

В этом случае целевой конструктор выбирается перегрузкой разрешение и выполняется первым, затем управление возвращается к делегирующий конструктор и его тело выполнено.

Делегирующие конструкторы не могут быть рекурсивными.

class Foo {
public: 
  Foo(char x, int y) {}
  Foo(int y) : Foo('a', y) {} // Foo(int) delegates to Foo(char,int)
};

Обратите внимание, что делегирующий конструктор является предложением "все или ничего"; если конструктор делегирует полномочия другому конструктору, вызывающему конструктору не разрешается иметь какие-либо другие члены в его списке инициализации. Это имеет смысл, если вы думаете об инициализации элементов const / reference один раз и только один раз.

Было бы легче проверить, чем решить :) Попробуйте это:

#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

итак :)

Этот подход может работать для некоторых типов классов (когда оператор присваивания ведет себя «хорошо»):

Foo::Foo()
{
    // do what every Foo is needing
    ...
}

Foo::Foo(char x)
{
    *this = Foo();

    // do the special things for a Foo with char
    ...
}

Я бы предложил использовать метод private friend, который реализует логику приложения конструктора и вызывается различными конструкторами. Вот пример:

Предположим, у нас есть класс с именем StreamArrayReader с некоторыми частными полями:

private:
    istream * in;
      // More private fields

И мы хотим определить два конструктора:

public:
    StreamArrayReader(istream * in_stream);
    StreamArrayReader(char * filepath);
    // More constructors...

Где второй просто использует первый (и, конечно, мы не хотим дублировать реализацию первого). В идеале хотелось бы сделать что-то вроде:

StreamArrayReader::StreamArrayReader(istream * in_stream){
    // Implementation
}

StreamArrayReader::StreamArrayReader(char * filepath) {
    ifstream instream;
    instream.open(filepath);
    StreamArrayReader(&instream);
    instream.close();
}

Однако в C ++ это запрещено. По этой причине мы можем определить метод частного друга следующим образом, который реализует то, что должен делать первый конструктор:

private:
  friend void init_stream_array_reader(StreamArrayReader *o, istream * is);

Теперь этот метод (потому что он друг) имеет доступ к закрытым полям o. Тогда первый конструктор станет:

StreamArrayReader::StreamArrayReader(istream * is) {
    init_stream_array_reader(this, is);
}

Обратите внимание, что при этом не создается несколько копий для вновь созданных копий. Второй становится:

StreamArrayReader::StreamArrayReader(char * filepath) {
    ifstream instream;
    instream.open(filepath);
    init_stream_array_reader(this, &instream);
    instream.close();
}

То есть вместо того, чтобы один конструктор вызывал другой, оба вызывают частного друга!

При вызове конструктора он фактически выделяет память либо из стека, либо из кучи. Таким образом, вызов конструктора в другом конструкторе создает локальную копию. Итак, мы модифицируем другой объект, а не тот, на котором сосредоточены.

В Visual C ++ вы также можете использовать эту нотацию внутри конструктора: this-> Classname :: Classname (параметры другого конструктора). См. Пример ниже:

class Vertex
{
 private:
  int x, y;
 public:
  Vertex(int xCoo, int yCoo): x(xCoo), y(yCoo) {}
  Vertex()
  {
   this->Vertex::Vertex(-1, -1);
  }
};

Я не знаю, работает ли он где-то еще, я тестировал его только в Visual C ++ 2003 и 2008. Вы также можете вызвать несколько конструкторов таким образом, я полагаю, точно так же, как в Java и C #.

P.S .: Честно говоря, я был удивлен, что об этом не упоминалось ранее.

Другой вариант, который еще не был показан, - разделить ваш класс на два, обернув легкий интерфейсный класс вокруг вашего исходного класса для достижения желаемого эффекта:

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

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

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

Это может стать беспорядочным, если у вас есть много конструкторов, которые должны вызывать свой аналог "следующего уровня выше", но для горстки конструкторов это должно быть работоспособным.

В 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) {}
};

Это должно устранить необходимость в создании вспомогательного метода инициализации. И по-прежнему рекомендуется не вызывать никаких виртуальных функций в конструкторах или деструкторах, чтобы избежать использования каких-либо членов, которые могут быть не инициализированы.

Если вы хотите быть злым, вы можете использовать на месте "новый" оператор:

class Foo() {
    Foo() { /* default constructor deliciousness */ }
    Foo(Bar myParam) {
      new (this) Foo();
      /* bar your param all night long */
    } 
};

Кажется, у меня работает.

редактировать

Как указывает @ElvedinHamzagic, если Foo содержит объект, который выделяет память, этот объект может не быть освобожден. Это еще больше усложняет ситуацию.

Более общий пример:

class Foo() {
private:
  std::vector<int> Stuff;
public:
    Foo()
      : Stuff(42)
    {
      /* default constructor deliciousness */
    }

    Foo(Bar myParam)
    {
      this->~Foo();
      new (this) Foo();
      /* bar your param all night long */
    } 
};

Выглядит, конечно, немного менее элегантно. Решение @ JohnIdol намного лучше.

Я считаю, что вы можете вызвать конструктор из конструктора. Он скомпилируется и запустится. Я недавно видел, как кто-то это делал, и он работал как в Windows, так и в Linux.

Он просто не делает того, что вы хотите. Внутренний конструктор создаст временный локальный объект, который будет удален после возврата внешнего конструктора. Они также должны быть разными конструкторами, иначе вы создадите рекурсивный вызов.

Ссылка: https://isocpp.org/wiki/faq/ctors#init-methods

C ++ 11 : Да!

C ++ 11 и более поздние версии имеют ту же функцию (называемую делегирующими конструкторами).

Синтаксис немного отличается от C #:

class Foo {
public: 
  Foo(char x, int y) {}
  Foo(int y) : Foo('a', y) {}
};

C ++ 03 : Нет

Стоит отметить, что вы можете вызывать конструктор родительского класса в своем конструкторе, например:

 class A { /* ... */ };
    
    class B : public A
    {
        B() : A()
        {
            // ...
        }
    };

Но нет, вы не можете вызвать другой конструктор того же класса до C ++ 03.

Нет, вы не можете вызывать один конструктор из другого в C ++ 03 (так называемый делегирующий конструктор).

Это изменилось в C ++ 11 (также известном как C ++ 0x), в котором добавлена ​​поддержка следующего синтаксиса:
(пример взят из Википедии)

class SomeType
{
  int number;

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

Нет, в C ++ нельзя вызывать конструктор из конструктора. Как указал Уоррен, вы можете:

• Перегрузите конструктор, используя разные подписи
• Используйте значения по умолчанию для аргументов, чтобы сделать доступную "более простую" версию

Обратите внимание, что в первом случае нельзя уменьшить дублирование кода, вызывая один конструктор из другого. Конечно, у вас может быть отдельный частный / защищенный метод, который выполняет всю инициализацию, и позволить конструктору в основном заниматься обработкой аргументов.

Если я правильно понял ваш вопрос, вы спрашиваете, можно ли вызывать несколько конструкторов в C ++?

Если это то, что вы ищете, то нет - это невозможно.

Вы, безусловно, можете иметь несколько конструкторов, каждый с уникальными сигнатурами аргументов, а затем вызывать тот, который вам нужен, при создании экземпляра нового объекта.

У вас может быть даже один конструктор с аргументами по умолчанию на конце.

Но у вас может не быть нескольких конструкторов, а затем вызывать каждый из них отдельно.