Por que não há problema em retornar um 'vetor' de uma função?

Por favor, considere este código. Já vi esse tipo de código várias vezes. wordsé um vetor local. Como é possível retorná-lo de uma função?

Podemos garantir que não morrerá?

 std::vector<std::string> read_file(const std::string& path)
 {
    std::ifstream file("E:\\names.txt");

    if (!file.is_open())
    {
        std::cerr << "Unable to open file" << "\n";
        std::exit(-1);
    }

    std::vector<string> words;//this vector will be returned
    std::string token;

    while (std::getline(file, token, ','))
    {
        words.push_back(token);
    }

    return words;
}

Podemos garantir que não morrerá?

Desde que nenhuma referência seja retornada, é perfeitamente normal fazê-lo. wordsserá movido para a variável que recebe o resultado.

A variável local sairá do escopo. depois de movido (ou copiado).

Pré C ++ 11:

A função não retornará a variável local, mas sim uma cópia dela. Seu compilador pode, entretanto, realizar uma otimização onde nenhuma ação de cópia real é feita.

Veja esta pergunta e resposta para mais detalhes.

C ++ 11:

A função irá mover o valor. Veja esta resposta para mais detalhes.

Eu acho que você está se referindo ao problema em C (e C ++) que retornar um array de uma função não é permitido (ou pelo menos não funcionará como esperado) - isso ocorre porque o retorno do array irá (se você escrever em a forma simples) retorna um ponteiro para a matriz real na pilha, que então é imediatamente removida quando a função retorna.

Mas, neste caso, funciona, porque std::vectoré uma classe, e classes, como structs, podem (e serão) copiadas para o contexto do chamador. [Na verdade, a maioria dos compiladores otimizará esse tipo específico de cópia usando algo chamado "Otimização do valor de retorno", especificamente introduzida para evitar a cópia de objetos grandes quando eles são retornados de uma função, mas isso é uma otimização e, da perspectiva dos programadores, se comporte como se o construtor de atribuição fosse chamado para o objeto]

Contanto que você não retorne um ponteiro ou uma referência a algo que está dentro do retorno da função, tudo bem.

Para entender bem o comportamento, você pode executar este código:

#include <iostream>

class MyClass
{
  public:
    MyClass() { std::cout << "run constructor MyClass::MyClass()" << std::endl; }
    ~MyClass() { std::cout << "run destructor MyClass::~MyClass()" << std::endl; }
    MyClass(const MyClass& x) { std::cout << "run copy constructor MyClass::MyClass(const MyClass&)" << std::endl; }
    MyClass& operator = (const MyClass& x) { std::cout << "run assignation MyClass::operator=(const MyClass&)" << std::endl; }
};

MyClass my_function()
{
  std::cout << "run my_function()" << std::endl;
  MyClass a;
  std::cout << "my_function is going to return a..." << std::endl;
  return a;
}

int main(int argc, char** argv)
{
  MyClass b = my_function();

  MyClass c;
  c = my_function();

  return 0;
}

O resultado é o seguinte:

run my_function()
run constructor MyClass::MyClass()
my_function is going to return a...
run constructor MyClass::MyClass()
run my_function()
run constructor MyClass::MyClass()
my_function is going to return a...
run assignation MyClass::operator=(const MyClass&)
run destructor MyClass::~MyClass()
run destructor MyClass::~MyClass()
run destructor MyClass::~MyClass()

Observe que este exemplo foi fornecido no contexto C ++ 03, ele poderia ser melhorado para C ++> = 11

Não concordo e não recomendo devolver vector:

vector <double> vectorial(vector <double> a, vector <double> b)
{
    vector <double> c{ a[1] * b[2] - b[1] * a[2], -a[0] * b[2] + b[0] * a[2], a[0] * b[1] - b[0] * a[1] };
    return c;
}

Isso é muito mais rápido:

void vectorial(vector <double> a, vector <double> b, vector <double> &c)
{
    c[0] = a[1] * b[2] - b[1] * a[2]; c[1] = -a[0] * b[2] + b[0] * a[2]; c[2] = a[0] * b[1] - b[0] * a[1];
}

Testei no Visual Studio 2017 com os seguintes resultados no modo de lançamento:

8,01 MOPs por referência
5,09 MOPs retornando vetor

No modo de depuração, as coisas são muito piores:

0,053 MOPS por referência
0,034 MOPs por vetor de retorno

Na verdade, isso é uma falha de design. Você não deve usar um valor de retorno para nada que não seja um primitivo para nada que não seja relativamente trivial.

A solução ideal deve ser implementada através de um parâmetro de retorno com decisão sobre referência / ponteiro e o uso adequado de um "const \ 'y \' ness" como descritor.

Além disso, você deve perceber que o rótulo em uma matriz em C e C ++ é efetivamente um ponteiro e sua assinatura é efetivamente um deslocamento ou um símbolo de adição.

Portanto, o rótulo ou ptr array_ptr === rótulo do array, portanto, retornando foo [deslocamento] está realmente dizendo o elemento de retorno na localização do ponteiro de memória foo + deslocamento do tipo tipo de retorno.