Việc sử dụng 'tự động' của C ++ 11 có thể cải thiện hiệu suất không?

Tôi có thể thấy lý do tại sao autoloại trong C ++ 11 cải thiện tính chính xác và khả năng bảo trì. Tôi đã đọc rằng nó cũng có thể cải thiện hiệu suất ( Hầu như luôn luôn tự động bởi Herb Sutter), nhưng tôi bỏ lỡ một lời giải thích tốt.

• Làm thế nào có thể autocải thiện hiệu suất?
• Bất cứ ai có thể đưa ra một ví dụ?

autocó thể hỗ trợ hiệu suất bằng cách tránh chuyển đổi ngầm im lặng . Một ví dụ tôi thấy hấp dẫn là như sau.

std::map<Key, Val> m;
// ...

for (std::pair<Key, Val> const& item : m) {
    // do stuff
}

Thấy lỗi không? Chúng tôi đang ở đây, nghĩ rằng chúng tôi thanh lịch lấy mọi vật phẩm trên bản đồ bằng cách tham chiếu và sử dụng biểu thức phạm vi mới để làm rõ ý định của chúng tôi, nhưng thực sự chúng tôi đang sao chép mọi yếu tố. Điều này là do std::map<Key, Val>::value_typelà std::pair<const Key, Val>, không phải std::pair<Key, Val>. Do đó, khi chúng tôi (ngầm) có:

std::pair<Key, Val> const& item = *iter;

Thay vì lấy một tham chiếu đến một đối tượng hiện có và để nó ở đó, chúng ta phải thực hiện chuyển đổi loại. Bạn được phép lấy tham chiếu const đến một đối tượng (hoặc tạm thời) thuộc loại khác miễn là có sẵn một chuyển đổi ngầm định, ví dụ:

int const& i = 2.0; // perfectly OK

Chuyển đổi loại là một chuyển đổi ngầm định được phép với cùng lý do bạn có thể chuyển đổi a const Keythành a Key, nhưng chúng tôi phải xây dựng tạm thời loại mới để cho phép điều đó. Do đó, vòng lặp của chúng tôi có hiệu quả:

std::pair<Key, Val> __tmp = *iter;       // construct a temporary of the correct type
std::pair<Key, Val> const& item = __tmp; // then, take a reference to it

(Tất nhiên, thực tế không có một __tmpđối tượng, nó chỉ ở đó để minh họa, trong thực tế, tạm thời không tên chỉ bị ràng buộc itemtrong suốt cuộc đời của nó).

Chỉ cần thay đổi thành:

for (auto const& item : m) {
    // do stuff
}

chỉ lưu cho chúng tôi một tấn bản sao - bây giờ loại được tham chiếu phù hợp với loại trình khởi tạo, do đó không cần tạm thời hoặc chuyển đổi, chúng tôi chỉ có thể thực hiện tham chiếu trực tiếp.

Bởi vì autosuy ra loại biểu thức khởi tạo, không có chuyển đổi loại liên quan. Kết hợp với các thuật toán templated, điều này có nghĩa là bạn có thể có được một tính toán trực tiếp hơn so với việc bạn tự tạo một loại - đặc biệt là khi bạn đang xử lý các biểu thức mà loại bạn không thể đặt tên!

Một ví dụ điển hình đến từ (ab) bằng cách sử dụng std::function:

std::function<bool(T, T)> cmp1 = std::bind(f, _2, 10, _1);  // bad
auto cmp2 = std::bind(f, _2, 10, _1);                       // good
auto cmp3 = [](T a, T b){ return f(b, 10, a); };            // also good

std::stable_partition(begin(x), end(x), cmp?);

Với cmp2và cmp3, toàn bộ thuật toán có thể thực hiện cuộc gọi so sánh, trong khi nếu bạn xây dựng một std::functionđối tượng, không chỉ cuộc gọi không thể được nội tuyến, mà bạn còn phải trải qua quá trình tra cứu đa hình trong phần bên trong của hàm bọc.

Một biến thể khác về chủ đề này là bạn có thể nói:

auto && f = MakeAThing();

Đây luôn là một tham chiếu, ràng buộc với giá trị của biểu thức gọi hàm và không bao giờ xây dựng bất kỳ đối tượng bổ sung nào. Nếu bạn không biết loại giá trị được trả về, bạn có thể bị buộc phải xây dựng một đối tượng mới (có thể là tạm thời) thông qua một cái gì đó như T && f = MakeAThing(). (Hơn nữa, auto &&thậm chí hoạt động khi loại trả về không thể di chuyển và giá trị trả về là một giá trị.)

Có hai loại.

autocó thể tránh được loại tẩy. Có các loại không thể đặt tên (như lambdas) và các loại gần như không thể đặt tên (như kết quả của std::bindhoặc các mẫu biểu thức khác giống như mọi thứ).

Nếu không auto, cuối cùng bạn phải gõ xóa dữ liệu xuống một cái gì đó như thế nào std::function. Loại tẩy có chi phí.

std::function<void()> task1 = []{std::cout << "hello";};
auto task2 = []{std::cout << " world\n";};

task1có loại tổng phí xóa - phân bổ heap có thể, khó khăn trong việc sắp xếp nó và chi phí gọi bảng chức năng ảo. task2không có Lambdas cần tự động hoặc các hình thức khấu trừ loại khác để lưu trữ mà không xóa kiểu; các loại khác có thể phức tạp đến mức họ chỉ cần nó trong thực tế.

Thứ hai, bạn có thể nhận được các loại sai. Trong một số trường hợp, loại sai sẽ hoạt động có vẻ hoàn hảo, nhưng sẽ gây ra một bản sao.

Foo const& f = expression();

sẽ biên dịch nếu expression()trả về Bar const&hoặc Barthậm chí Bar&, nơi Foocó thể được xây dựng từ đó Bar. Tạm thời Foosẽ được tạo, sau đó ràng buộc fvà thời gian tồn tại của nó sẽ được kéo dài cho đến khi fbiến mất.

Lập trình viên có thể có ý định Bar const& fvà không có ý định tạo một bản sao ở đó, nhưng một bản sao được tạo ra bất kể.

Ví dụ phổ biến nhất là loại *std::map<A,B>::const_iterator, std::pair<A const, B> const&không phải std::pair<A,B> const&, nhưng lỗi là một loại lỗi mà âm thầm chi phí hiệu suất. Bạn có thể xây dựng một std::pair<A, B>từ a std::pair<const A, B>. (Chìa khóa trên bản đồ là const, vì chỉnh sửa nó là một ý tưởng tồi)

Cả @Barry và @KerrekSB lần đầu tiên minh họa hai nguyên tắc này trong câu trả lời của họ. Đây chỉ đơn giản là một nỗ lực để làm nổi bật hai vấn đề trong một câu trả lời, với từ ngữ nhắm vào vấn đề chứ không phải là ví dụ trung tâm.

Ba câu trả lời hiện tại đưa ra các ví dụ trong đó việc sử dụng autogiúp Giúp làm cho nó ít có khả năng vô tình làm bi quan đến hiệu quả làm cho nó "cải thiện hiệu suất".

Có một mặt trái của đồng tiền. Sử dụng autovới các đối tượng có toán tử không trả về đối tượng cơ bản có thể dẫn đến mã không chính xác (vẫn có thể biên dịch và chạy được). Ví dụ: câu hỏi này hỏi cách sử dụng autocác kết quả khác nhau (không chính xác) bằng thư viện Eigen, tức là các dòng sau

const auto    resAuto    = Ha + Vector3(0.,0.,j * 2.567);
const Vector3 resVector3 = Ha + Vector3(0.,0.,j * 2.567);

std::cout << "resAuto = " << resAuto <<std::endl;
std::cout << "resVector3 = " << resVector3 <<std::endl;

dẫn đến đầu ra khác nhau. Phải thừa nhận rằng, điều này chủ yếu là do đánh giá lười biếng của Eigens, nhưng mã đó là / nên được minh bạch cho người dùng (thư viện).

Mặc dù hiệu suất không bị ảnh hưởng nhiều ở đây, sử dụng autođể tránh sự bi quan không chủ ý có thể được phân loại là tối ưu hóa sớm, hoặc ít nhất là sai;).