Чому добре повернути 'вектор' з функції?

Будь ласка, врахуйте цей код. Цей тип коду я бачив уже кілька разів. words- локальний вектор. Як можливо повернути його з функції?

Чи можемо ми гарантувати, що він не помре?

 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;
}

Чи можемо ми гарантувати, що він не помре?

Поки довідки не повертаються, це цілком чудово робити. wordsбуде переміщено до змінної, що отримує результат.

Локальна змінна вийде за межі області. після його переміщення (або копіювання).

Попередньо C ++ 11:

Функція не поверне локальну змінну, а скоріше її копію. Однак ваш компілятор може здійснити оптимізацію, коли фактичні дії з копіювання не здійснюються.

Дивіться це запитання та відповідь для подальшої інформації.

C ++ 11:

Функція перемістить значення. Дивіться цю відповідь для отримання більш детальної інформації.

Я думаю, ви посилаєтесь на проблему в C (і C ++), що повернення масиву з функції заборонено (або, принаймні, не буде працювати, як очікувалося) - це тому, що повернення масиву буде (якщо ви запишете його в проста форма) повернути вказівник на фактичний масив стека, який потім негайно видаляється, коли функція повертається.

Але в цьому випадку це працює, тому що std::vectorце клас, і класи, як і структури, можуть (і будуть) скопійовані в контекст виклику. [Насправді більшість компіляторів оптимізують саме цей тип копії, використовуючи щось, що називається "Оптимізація поверненого значення", спеціально введене для уникнення копіювання великих об'єктів, коли вони повертаються з функції, але це оптимізація, і з точки зору програмістів, це буде вести себе так, ніби конструктор присвоєння викликався для об'єкта]

Поки ви не повернете вказівник або посилання на те, що знаходиться в межах функції, що повертається, у вас все в порядку.

Щоб добре зрозуміти поведінку, ви можете запустити цей код:

#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;
}

Вихід такий:

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()

Зауважте, що цей приклад надано в контексті C ++ 03, його можна було вдосконалити для C ++> = 11

Я не згоден і не рекомендую повертати 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;
}

Це набагато швидше:

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];
}

Я перевірив на Visual Studio 2017 наступні результати у режимі випуску:

8,01 МОП за посиланням
5,09 МОП, що повертає вектор

У режимі налагодження все набагато гірше:

0.053 МОП за посиланням
0,034 МОП за поверненим вектором

Це насправді провал дизайну. Ви не повинні використовувати значення повернення для чогось не примітивного для чогось, що не є відносно тривіальним.

Ідеальне рішення має бути реалізовано через параметр повернення з рішенням про посилання / покажчик та належним використанням "const \ 'y \' ness" в якості дескриптора.

Крім цього, ви повинні усвідомити, що мітка на масиві в C і C ++ є ефективно покажчиком, і його підписка фактично є зміщенням або символом додавання.

Отже, мітка або ptr array_ptr === мітка масиву таким чином повертає foo [offset] насправді говорить елемент return у місці розташування вказівника пам'яті foo + зміщення типу повернення типу.