C++ Programming Labs

Lab 22: Move Semantics

Expert

Coding Challenge

Your Task: Understand move semantics - a C++11 feature that enables efficient transfer of resources without copying. This is crucial for performance optimization.

Detailed Requirements:
1. Understand lvalues vs rvalues:

int x = 10;      // x is lvalue (has address)
int y = x + 5;   // x+5 is rvalue (temporary)
int&& rref = 20; // rvalue reference to temporary

2. Use std::move to cast to rvalue:

string s1 = "Hello";
string s2 = std::move(s1);  // s1's data moved to s2
// s1 is now in valid but unspecified state

3. Create a class with move constructor:

class Buffer {
    int* data;
    size_t size;
public:
    // Move constructor
    Buffer(Buffer&& other) noexcept 
        : data(other.data), size(other.size) {
        other.data = nullptr;
        other.size = 0;
    }
    // Move assignment
    Buffer& operator=(Buffer&& other) noexcept {
        if (this != &other) {
            delete[] data;
            data = other.data;
            size = other.size;
            other.data = nullptr;
            other.size = 0;
        }
        return *this;
    }
};

Expected Output:

Original: Hello World
After move, s2: Hello World
s1 is now empty
Move constructor called
Move assignment called

Requirements Checklist

Use std::move to transfer ownership

Create rvalue reference with &&

Implement move constructor

Use noexcept specifier

Implement move assignment operator

Set source to valid empty state after move

#include <iostream>
#include <string>
#include <utility>
using namespace std;

class MyString {
    char* data;
    size_t len;
public:
    // Constructor
    MyString(const char* s) {
        len = strlen(s);
        data = new char[len + 1];
        strcpy(data, s);
        cout << "Constructor called" << endl;
    }
    
    // TODO: Move constructor
    // MyString(MyString&& other) noexcept 
    //     : data(other.data), len(other.len) {
    //     other.data = nullptr;
    //     other.len = 0;
    //     cout << "Move constructor called" << endl;
    // }
    
    // TODO: Move assignment operator
    // MyString& operator=(MyString&& other) noexcept {
    //     if (this != &other) {
    //         delete[] data;
    //         data = other.data;
    //         len = other.len;
    //         other.data = nullptr;
    //         other.len = 0;
    //     }
    //     cout << "Move assignment called" << endl;
    //     return *this;
    // }
    
    ~MyString() { delete[] data; }
    
    void print() const {
        if (data) cout << data;
        else cout << "(empty)";
    }
};

int main() {
    // TODO: Test with std::string first
    // string s1 = "Hello World";
    // cout << "Original: " << s1 << endl;
    // string s2 = std::move(s1);
    // cout << "After move, s2: " << s2 << endl;
    // cout << "s1 is now: " << (s1.empty() ? "empty" : s1) << endl;
    
    // TODO: Test MyString move
    // MyString str1("Test");
    // MyString str2 = std::move(str1);
    
    return 0;
}

Output

// Click "Run Code" to compile and execute // Your program output will appear here

Hints & Tips

• Move: T(T&& other) noexcept

• Transfer: std::move(obj)

• Always use noexcept for move operations

• Set source to valid empty state after move

Progress: 0/6

Score: 0/100

0%

Lab Results

Review feedback below

Lab 23: Multithreading Basics

Expert

Coding Challenge

Your Task: Learn C++11 threading basics. Create and manage threads to run code concurrently.

Detailed Requirements:
1. Include thread header:
#include <thread>

2. Create and run a thread:

void task() {
    cout << "Running in thread" << endl;
}
thread t(task);  // Start thread
t.join();        // Wait for completion

3. Thread with lambda:

thread t([]() {
    cout << "Lambda thread" << endl;
});
t.join();

4. Thread with parameters:

void greet(string name) {
    cout << "Hello, " << name << endl;
}
thread t(greet, "World");
t.join();

5. Using mutex for synchronization:

#include 
mutex mtx;
void safe_print(int id) {
    lock_guard lock(mtx);
    cout << "Thread " << id << endl;
}

Expected Output:

Main thread starting
Worker thread running
Thread ID: 12345
Counter value: 1000
All threads complete

Requirements Checklist

Include thread header

Create a thread object

Use join() to wait for thread

Pass function to thread

Include mutex for synchronization

Use lock_guard for safe locking

#include <iostream>
// TODO: Include thread and mutex headers
// #include <thread>
// #include <mutex>

using namespace std;

// mutex mtx;
// int counter = 0;

// TODO: Create a worker function
// void worker(int id) {
//     lock_guard<mutex> lock(mtx);
//     cout << "Worker thread " << id << " running" << endl;
//     counter++;
// }


int main() {
    // cout << "Main thread starting" << endl;
    
    // TODO: Create threads
    // thread t1(worker, 1);
    // thread t2(worker, 2);
    
    // TODO: Get thread ID
    // cout << "Thread 1 ID: " << t1.get_id() << endl;
    
    // TODO: Join threads
    // t1.join();
    // t2.join();
    
    // cout << "Counter value: " << counter << endl;
    // cout << "All threads complete" << endl;
    
    return 0;
}

Output

// Click "Run Code" to compile and execute // Your program output will appear here

Hints & Tips

• Create: thread t(function, args...);

• Wait: t.join();

• Detach: t.detach();

• Lock: lock_guard<mutex> lock(mtx);

Progress: 0/6

Score: 0/100

0%

Lab Results

Review feedback below

Lab 24: RAII Pattern

Expert

Coding Challenge

Your Task: Implement RAII (Resource Acquisition Is Initialization) - a fundamental C++ idiom for managing resources safely.

Detailed Requirements:
1. RAII Principle:
   • Acquire resources in constructor
   • Release resources in destructor
   • Resources are automatically freed when object goes out of scope

2. Create a FileHandle RAII class:

class FileHandle {
    FILE* file;
public:
    FileHandle(const char* name, const char* mode) {
        file = fopen(name, mode);
        if (!file) throw runtime_error("Cannot open");
    }
    ~FileHandle() {
        if (file) fclose(file);
        cout << "File closed automatically" << endl;
    }
    // Disable copying
    FileHandle(const FileHandle&) = delete;
    FileHandle& operator=(const FileHandle&) = delete;
};

3. Create a Timer RAII class:

class Timer {
    chrono::time_point start;
    string name;
public:
    Timer(string n) : name(n), 
        start(chrono::high_resolution_clock::now()) {}
    ~Timer() {
        auto end = chrono::high_resolution_clock::now();
        auto duration = chrono::duration_cast(end - start);
        cout << name << " took " << duration.count() << "ms" << endl;
    }
};

Expected Output:

Resource acquired
Using resource...
Resource released automatically
Timer: Operation took 100ms

Requirements Checklist

Acquire resource in constructor

Release resource in destructor

Delete copy constructor (= delete)

Delete copy assignment (= delete)

Use scope to trigger automatic cleanup

Print message showing automatic release

#include <iostream>
#include <string>
using namespace std;

// TODO: Create RAII Resource class
// class Resource {
// private:
//     string name;
//     int* data;
// public:
//     // Constructor acquires resource
//     Resource(string n) : name(n) {
//         data = new int[100];
//         cout << name << " acquired" << endl;
//     }
//     
//     // Destructor releases resource
//     ~Resource() {
//         delete[] data;
//         cout << name << " released automatically" << endl;
//     }
//     
//     // Delete copy operations
//     Resource(const Resource&) = delete;
//     Resource& operator=(const Resource&) = delete;
//     
//     void use() {
//         cout << "Using " << name << "..." << endl;
//     }
// };


int main() {
    cout << "Entering scope..." << endl;
    
    // TODO: Use RAII in a scope
    // {
    //     Resource res("MyResource");
    //     res.use();
    //     // Resource automatically released when scope ends
    // }
    
    cout << "Exited scope" << endl;
    
    // TODO: Show RAII with multiple resources
    // {
    //     Resource r1("Resource1");
    //     Resource r2("Resource2");
    //     r1.use();
    //     r2.use();
    // } // Both released in reverse order
    
    cout << "Program complete" << endl;
    
    return 0;
}

Output

// Click "Run Code" to compile and execute // Your program output will appear here

Hints & Tips

• Acquire in constructor, release in destructor

• Delete copy: T(const T&) = delete;

• Use scopes { } to control lifetime

• Destructors called in reverse order of construction

Progress: 0/6

Score: 0/100

0%

Lab Results

Review feedback below

Move Semantics, Threads & RAII - Module 8

Requirements Checklist

Lab Results

Requirements Checklist

Lab Results

Requirements Checklist

Lab Results

Congratulations!