Bài 13: C++11 1
Các phiên bản C++ C++98 (đã học trong các bài trước): Được ISO chuẩn hoá lần đầu tiên C++03: Một số thay đổi nhỏ C++0x / C++11: Rất nhiều cập nhật mới Nhiều tính năng được lấy lại từ thư viện boost C++14: Một số mở rộng so với C++11 C++17: Đang thảo luận 2
Tự suy đoán kiểu Ví dụ: map<string, pair<string, int>> m; // map<string, pair<string, int>>::iterator itr = m.begin(); auto itr = m.begin(); // pair<string, int>& a = m["ktlt"]; auto& a = m["ktlt"]; // pair<string, int> b; decltype(a) b; 3
Vòng lặp for theo khoảng (range-based for loop) double a[10]; list<string> l; vector<complex> v; for (int x : a) { //... for (string& x : l) { //... for (complex& x : v) { //... 4
Con trỏ thông minh (smart pointers) Là kiểu trừu tượng cho phép mô phỏng các con trỏ, nhưng bổ sung thêm một số tính năng khác: Quản lý bộ nhớ tự động Kiểm tra phạm vi Ví dụ: shared_ptr<int> p1(new int(10)); shared_ptr<int> p2 = p1; *p2 = 20; // bộ nhớ sẽ được thu hồi khi // tham chiếu cuối cùng được huỷ 5
Đa luồng (multithreading) & Lập trình song song (concurrency) 6
Luồng (threads) Cho phép thực thi các nhiệm vụ đồng thời (song song, không đồng bộ), chú ý phân biệt luồng và tiến trình (process) Luôn có ít nhất một luồng trong chương trình, được tạo cho hàm main: được gọi là luồng chính Trước C++11, các luồng được quản lý bởi các thư viện ngoài: POSIX thread (pthread) Windows API OpenMP MPI Từ C++11, đa luồng là một tính năng có sẵn #include <thread> Lớp std::thread Mỗi luồng được thực thi trong một hàm gọi là thread function 7
Ví dụ #include <iostream> #include <chrono> #include <thread> using namespace std; void task1() { for (int i = 0; i < 100; i++) { this_thread::sleep_for( chrono::milliseconds(100)); cout << "Thread 1\n"; void task2() { for (int i = 0; i < 100; i++) { this_thread::sleep_for( chrono::milliseconds(100)); cout << "Thread 2\n"; void main() { thread t(task1); task2(); t.join(); 8
Luồng với tham số #include <iostream> #include <chrono> #include <thread> using namespace std; void task(int* n) { 9 int i, t; for (i=0; i<100; i++) { t = *n; this_thread::sleep_for( chrono::milliseconds(1)); *n = t + 1; void main() { thread a[10]; int i, n = 0; for (i=0; i<10; i++) a[i] = thread( task, &n); for (i=0; i<10; i++) a[i].join(); cout << n << endl;
Critical sections & quản lý sử dụng tài nguyên Các luồng trong cùng một process chia sẻ bộ nhớ Một luồng có thể sử dụng bộ nhớ được cấp phát từ các luồng khác Việc cập nhật các biến chung từ các luồng khác nhau có thể dẫn đến kết quả không mong muốn Luồng 1 t = i; t ++; i = t; Luồng 2 t = i; t ++; i = t; Giá trị i = 10 t#1 = 10 t#2 = 10 t#1 = 11 t#2 = 11 i = 11 i = 11 Việc sử dụng tài nguyên phải được quản lý Critical sections Các tài nguyên có thể được hiểu theo nghĩa rộng 10
Lớp mutex Mutex = mutual exclusion (loại trừ lẫn nhau) không quá 1 luồng thực thi đoạn mã ở một thời điểm #include <mutex> mutex m; void task(int* n) { int i, t; for (i=0; i<100; i++) { m.lock(); t = *n; this_thread::sleep_for(chrono::milliseconds(1)); *n = t + 1; m.unlock(); critical section 11
Lớp parallel_for Duyệt các phần tử và thực thi một hàm cho trước một cách song song (tối ưu theo số CPU của máy) #include <iostream> #include <thread> #include <chrono> #include <mutex> #include <ppl.h> using namespace std; using namespace concurrency; int n = 0; mutex m; 12 void task(int itr) { for (int i=0; i<100; i++) { m.lock(); int t = n; this_thread::sleep_for( chrono::milliseconds(1)); n = t + 1; m.unlock(); void main() { parallel_for(0, 10, task); cout << n << endl;
Hàm lambda 13
Khái niệm Còn gọi là hàm không tên, được định nghĩa trong các câu lệnh Thường được dùng như tham số khi gọi các hàm khác Có thể được chuyển kiểu thành hàm thông thường khi không có capture nào Cú pháp: [các-capture](các-tham-số) -> kiểu-trả-về { thực-thi các-capture: danh sách các biến thuộc phạm vi định nghĩa được sử dụng trong hàm, phân cách bằng dấu,. Ví dụ: [a, &b, c, &d]: a và c bằng giá trị, b và d bằng tham chiếu [&, a, b]: a và b bằng giá trị, còn lại bằng tham chiếu [=, &a, &b]: a và b bằng tham chiếu, còn lại bằng giá trị kiểu-trả-về: có thể bỏ qua nếu suy luận được 14
Ví dụ 1 const int n = 10; int x[n] = {...; std::sort(x, x + n, [](int a, int b) { return abs(a) < abs(b); ); Viết theo C++98: bool compare(int a, int b) { return abs(a) < abs(b); std::sort(x, x + n, compare); 15
Ví dụ 2 int func(int a, function<int (int)> lambda) { return lambda(a); void main() { int n = 10, m = 20; int p = func(n, [m](int i) { ); return i*m; cout << p << endl; 16
parallel_for void main() { int n = 0; mutex m; parallel_for(0, 10, [&m, &n](int itr) { for (int i = 0; i < 100; i++) { m.lock(); int t = n; this_thread::sleep_for(chrono::milliseconds(1)); n = t + 1; m.unlock(); ); cout << n << endl; 17
Tham chiếu rvalue & Ý nghĩa move 18
Lvalue và rvalue Mỗi biểu thức C++ là một lvalue hoặc rvalue Lvalues: các giá trị có thể tham chiếu (những gì có thể lưu giá trị, có thể được đặt ở vế trái của câu lệnh gán) Rvalues: các giá trị tạm thời không tồn tại sau khi biểu thức dùng nó kết thúc (chỉ được đặt ở vế phải của câu lệnh gán) Ví dụ: int i = 100; const int a = x * y; int& m = i; 19
Ý nghĩa move Xem constructor sao chép của lớp string: string& operator =(const string& str) { // Ví dụ sử dụng: s = "abc"; 1. Giải phóng các tài nguyên s sử dụng 2. Sao chép tài nguyên từ đối tượng tạm thời 3. Giải phóng đối tượng tạm, và do đó, giải phóng các tài nguyên nó sử dụng Không tối ưu về hiệu năng hoạt động! Tại sao không chuyển đổi (move) tài nguyên của các đối tượng cho nhau? 20
Tham chiếu rvalue Tham chiếu rvalue (string&&) là các tham chiếu tới rvalue, được dùng trong quá trình move s = "abc"; s = s1 + s2; string ss(s1 + s2); Tham chiếu truyền thống (string&) nay được gọi là tham chiếu lvalue, được sử dụng trong quá trình copy s = s1; string ss(s1); Ta cần phải định nghĩa thêm: 1 toán tử gán move (bên cạnh toán tử gán copy) 1 constructor move (bên cạnh constructor copy) 21
Các constructor copy và move class string { protected: char* p; public: string(const string& s) { //... (as before) string(const string&& s) { p = s.p; ; 22
Các toán tử gán copy và move class string { protected: char* p; public: string& operator =(const string& s) { //... (as before) string& operator =(const string&& s) { p = s.p; return *this; ; 23