Tại sao có thể trả về 'vectơ' từ một hàm?

Vui lòng xem xét mã này. Tôi đã thấy loại mã này vài lần. wordslà một vectơ địa phương. Làm cách nào để trả về nó từ một hàm?

Chúng ta có thể đảm bảo nó sẽ không chết?

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

Chúng ta có thể đảm bảo nó sẽ không chết?

Miễn là không có tham chiếu nào được trả về, bạn hoàn toàn có thể làm như vậy. wordssẽ được chuyển đến biến nhận kết quả.

Biến cục bộ sẽ vượt ra khỏi phạm vi. sau khi nó được di chuyển (hoặc sao chép).

Pre C ++ 11:

Hàm sẽ không trả về biến cục bộ mà là một bản sao của nó. Tuy nhiên, trình biên dịch của bạn có thể thực hiện tối ưu hóa mà không có hành động sao chép thực tế nào được thực hiện.

Xem câu hỏi và câu trả lời này để biết thêm chi tiết.

C ++ 11:

Hàm sẽ di chuyển giá trị. Xem câu trả lời này để biết thêm chi tiết.

Tôi nghĩ rằng bạn đang đề cập đến vấn đề trong C (và C ++) rằng việc trả về một mảng từ một hàm không được phép (hoặc ít nhất là sẽ không hoạt động như mong đợi) - điều này là do trả về mảng sẽ (nếu bạn viết nó vào dạng đơn giản) trả về một con trỏ đến mảng thực trên ngăn xếp, sau đó sẽ bị xóa ngay khi hàm trả về.

Nhưng trong trường hợp này, nó hoạt động, bởi vì std::vectorlà một lớp và các lớp, như cấu trúc, có thể (và sẽ) được sao chép vào ngữ cảnh người gọi. [Trên thực tế, hầu hết các trình biên dịch sẽ tối ưu hóa loại bản sao cụ thể này bằng cách sử dụng thứ gọi là "Tối ưu hóa giá trị trả về", được giới thiệu cụ thể để tránh sao chép các đối tượng lớn khi chúng được trả về từ một hàm, nhưng đó là cách tối ưu hóa và từ góc độ lập trình viên, nó sẽ hành xử như thể hàm tạo phép gán được gọi cho đối tượng]

Miễn là bạn không trả về một con trỏ hoặc một tham chiếu đến một cái gì đó nằm trong hàm trả về, bạn vẫn ổn.

Để hiểu rõ về hành vi, bạn có thể chạy mã này:

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

Đầu ra như sau:

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

Lưu ý rằng ví dụ này được cung cấp trong ngữ cảnh C ++ 03, nó có thể được cải thiện cho C ++> = 11

Tôi không đồng ý và không khuyên bạn nên trả lại 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;
}

Điều này nhanh hơn nhiều:

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

Tôi đã thử nghiệm trên Visual Studio 2017 với kết quả sau ở chế độ phát hành:

8,01 MOP theo tham chiếu
vectơ trả về 5,09 MOPs

Trong chế độ gỡ lỗi, mọi thứ còn tệ hơn nhiều:

0,053 MOPS theo tham chiếu
0,034 MOPs theo vectơ trả về

Đây thực sự là một thất bại của thiết kế. Bạn không nên sử dụng giá trị trả về cho bất kỳ thứ gì không phải là giá trị nguyên thủy cho bất kỳ thứ gì không tương đối tầm thường.

Giải pháp lý tưởng nên được thực hiện thông qua một tham số trả về với quyết định về tham chiếu / con trỏ và sử dụng đúng "const \ 'y \' ness" làm bộ mô tả.

Trên hết, bạn nên nhận ra rằng nhãn trên một mảng trong C và C ++ thực sự là một con trỏ và đăng ký của nó thực sự là một phần bù hoặc một ký hiệu bổ sung.

Vì vậy, nhãn hoặc ptr array_ptr === mảng nhãn do đó trả về foo [offset] thực sự nói phần tử trả về tại vị trí con trỏ bộ nhớ foo + offset của kiểu trả về kiểu.