C++: دلالات النقل بعمق

std::vector<int> createVector() {
 std::vector<int> v = {1, 2, 3, 4, 5};
 return v; // إرجاع كائن مؤقت
}

std::vector<int> dest = createVector(); // نسخ الكائن المؤقت، مضيعة!

Copy count: 0

#include <iostream>

void process(int& x) {
 std::cout << "Processing lvalue: " << x << std::endl;
}

void process(int&& x) {
 std::cout << "Processing rvalue: " << x << std::endl;
}

int main() {
 int a = 10;
 process(a); // يستدعي process(int&)
 process(20); // يستدعي process(int&&)
 
 return 0;
}

#include <iostream>
#include <vector>
#include <utility>

int main() {
 std::vector<int> v1 = {1, 2, 3};
 std::vector<int> v2 = std::move(v1); // بناء النقل: موارد v1 "سُرقت" بواسطة v2
 
 std::cout << "v2 size: " << v2.size() << std::endl; // 3
 std::cout << "v1 size: " << v1.size() << std::endl; // 0 (v1 فارغة بعد النقل)
 
 return 0;
}

#include <iostream>
#include <cstring>

class String {
private:
 char* data;
 size_t length;

public:
 // باني
 String(const char* str) {
 length = strlen(str);
 data = new char[length + 1];
 strcpy(data, str);
 std::cout << "Construct: " << data << std::endl;
 }
 
 // باني نسخ (نسخة عميقة)
 String(const String& other) {
 length = other.length;
 data = new char[length + 1];
 strcpy(data, other.data);
 std::cout << "Copy construction: " << data << std::endl;
 }
 
 // باني نقل (سرقة الموارد)
 String(String&& other) noexcept {
 data = other.data; // سرقة المؤشر
 length = other.length;
 other.data = nullptr; // تعيين إلى قيمة فارغة، منع التحرير المزدوج
 other.length = 0;
 std::cout << "Move construction" << std::endl;
 }
 
 // مدمر
 ~String() {
 delete data;
 }
};

int main() {
 String s1("Hello");
 String s2 = std::move(s1); // يستدعي باني النقل
 
 return 0;
}

Construct: Hello
Move construction

Construct: Hello
Move construction

class Person {
 std::string name; // باستخدام string، يدعم النقل تلقائياً
 std::vector<int> scores; // باستخدام vector، يدعم النقل تلقائياً
 // لا حاجة لتعريف الخمسة الكبار!
}

#include <iostream>
#include <utility>

void process(int& x) {
 std::cout << "Processing lvalue" << std::endl;
}

void process(int&& x) {
 std::cout << "Processing rvalue" << std::endl;
}

template<typename T>
void wrapper(T&& arg) {
 process(std::forward<T>(arg)); // توجيه مثالي
}

int main() {
 int x = 10;
 wrapper(x); // يُوجَّه كقيمة يسارية
 wrapper(20); // يُوجَّه كقيمة يمنى
 
 return 0;
}

#include <iostream>
#include <vector>
#include <chrono>

int main() {
 std::vector<std::vector<int>> v;
 
 // اختبار النسخ
 auto start = std::chrono::high_resolution_clock::now();
 for (int i = 0; i < 10000; i++) {
 std::vector<int> temp(1000, 1);
 v.push_back(temp); // نسخ
 }
 auto end = std::chrono::high_resolution_clock::now();
 auto copy_time = std::chrono::duration<double>(end - start).count();
 
 v.clear();
 
 // اختبار النقل
 start = std::chrono::high_resolution_clock::now();
 for (int i = 0; i < 10000; i++) {
 std::vector<int> temp(1000, 1);
 v.push_back(std::move(temp)); // نقل
 }
 end = std::chrono::high_resolution_clock::now();
 auto move_time = std::chrono::duration<double>(end - start).count();
 
 std::cout << "Copy time: " << copy_time << " seconds" << std::endl;
 std::cout << "Move time: " << move_time << " seconds" << std::endl;
 
 return 0;
}

Copy time: 0.5 seconds
Move time: 0.01 seconds

#include <iostream>
#include <vector>
#include <string>

int main() {
    std::string original = "Hello, C++!";
    std::string moved = std::move(original);

    std::cout << "moved: " << moved << std::endl;
    std::cout << "original after move: \"" << original << "\"" << std::endl;

    return 0;
}

moved: Hello, C++!
original after move: ""