Duvida Sobre Sobrecarga De Construtores | C e C++ | Alura

Supondo Que eu Tenha um codigo desses:

ProgressaoGeometrica::ProgressaoGeometrica(int* Progressao, int TamanhoDaProgressao) {
    _Progressao = Progressao;
    _TamanhoDaProgressao = TamanhoDaProgressao;

}
ProgressaoGeometrica::ProgressaoGeometrica(std::vector<int> Progressao) {
    _TamanhoDaProgressao = Progressao.size();
    _Progressao = new int[_TamanhoDaProgressao+ 1];
    for (int i = 0; i < (int)_TamanhoDaProgressao; i++) {
        _Progressao[i] = (int)Progressao[i];
    }
}

no C++ é Possivel utilizar de alguma forma o operator para que esses dois construtores linguem para uma mesma funcao sem ter quer repetir o codigo?

ProgressaoGeometrica::ProgressaoGeometrica(int* Progressao, int TamanhoDaProgressao) {
    _Progressao = Progressao;
    _TamanhoDaProgressao = TamanhoDaProgressao;
    CalculaRazao();

}
ProgressaoGeometrica::ProgressaoGeometrica(std::vector<int> Progressao) {
    _TamanhoDaProgressao = Progressao.size();
    _Progressao = new int[_TamanhoDaProgressao+ 1];
    for (int i = 0; i < (int)_TamanhoDaProgressao; i++) {
        _Progressao[i] = (int)Progressao[i];
    }
    CalculaRazao();
}

Qual a melhor soluçao para resolver essa questão?

Olá, Vinicius!

Desculpe pela demora em obter retorno.

Para evitar a repetição de código nos construtores da classe ProgressaoGeometrica, você pode utilizar um construtor delegado. Um construtor delegado é um construtor que chama outro construtor da mesma classe, evitando a duplicação de código.

No seu caso, você pode criar um construtor delegado que recebe um int* e o tamanho da progressão, e outro construtor que recebe um std::vector<int>. Ambos os construtores chamariam um terceiro construtor que realiza as operações em comum, como o cálculo da razão.

Aqui está um exemplo de como você pode implementar isso:

ProgressaoGeometrica::ProgressaoGeometrica(int* Progressao, int TamanhoDaProgressao) : ProgressaoGeometrica(std::vector<int>(Progressao, Progressao + TamanhoDaProgressao)) {}

ProgressaoGeometrica::ProgressaoGeometrica(std::vector<int> Progressao) {
    _TamanhoDaProgressao = Progressao.size();
    _Progressao = new int[_TamanhoDaProgressao + 1];
    for (int i = 0; i < _TamanhoDaProgressao; i++) {
        _Progressao[i] = Progressao[i];
    }
    CalculaRazao();
}

ProgressaoGeometrica::ProgressaoGeometrica(const ProgressaoGeometrica& outra) {
    _TamanhoDaProgressao = outra._TamanhoDaProgressao;
    _Progressao = new int[_TamanhoDaProgressao + 1];
    for (int i = 0; i < _TamanhoDaProgressao; i++) {
        _Progressao[i] = outra._Progressao[i];
    }
    CalculaRazao();
}

Nesse exemplo, o primeiro construtor delega a chamada para o segundo construtor, passando um std::vector<int> criado a partir do int* e do tamanho da progressão. O terceiro construtor é adicionado para realizar a cópia dos elementos de outra instância da classe, se necessário.

Dessa forma, você evita a repetição do código de cálculo da razão nos construtores, mantendo a funcionalidade desejada.

Espero ter ajudado e bons estudos!