Exploring Thread Creation in C++11 Using Callable Objects

Creating threads in C++11 provides the ability to execute multiple tasks simultaneously, which greatly improves the efficiency and responsiveness of your programs. In this comprehensive guide, we will delve into five different approaches to creating threads using callable objects. Each method will be explained in detail, accompanied by practical examples to illustrate their usage and benefits. By the end of this exploration, you will have a solid understanding of how to effectively manage concurrent execution in your C++11 applications.

1. Function Pointer

A function pointer is a straightforward method for creating a thread. You provide a function along with its arguments to the constructor.

Example:

#include <iostream>
#include <thread>

// Function to be executed by the thread
void fun(int x) {
    while (x++ < 15) {
        std::cout << x << std::endl;
    }
}

int main() {
    // Create a thread that runs the function 'fun' with argument 10
    std::thread t1(fun, 10);
    t1.join(); // Wait for the thread to finish
    return 0;
}

Explanation:

• std::thread t1(fun, 10); creates a thread that runs the fun function with the argument 10.
• t1.join(); ensures the main thread waits for t1 to finish before continuing.

2. Lambda Function

Lambda functions are anonymous functions that can be defined inline, making them useful for executing short and simple tasks.

Example:

#include <iostream>
#include <thread>

int main() {
    // Create a thread using a lambda function
    std::thread t( {
        while (x-- > 0) {
            std::cout << x << std::endl;
        }
    }, 10);
    t.join(); // Wait for the thread to finish
    return 0;
}

Explanation:

• The lambda function { ... } is defined inline and passed to the thread.
• t.join(); ensures the main thread waits for t to finish.

3. Functor (Function Object)

A functor is an object of a class that overloads the function call operator. This allows the object to be called like a function.

Example:

#include <iostream>
#include <thread>

// Functor class
class Base {
public:
    void operator()(int x) {
        while (x-- > 0) {
            std::cout << x << std::endl;
        }
    }
};

int main() {
    // Create a thread using a functor
    std::thread t(Base(), 10);
    t.join(); // Wait for the thread to finish
    return 0;
}

Explanation:

• Base is a class with an overloaded operator().
• std::thread t(Base(), 10); creates a thread that runs the operator() function of a Base object with the argument 10.

4. Non-Static Member Function

Non-static member functions need an instance of an object to be invoked.

Example:

#include <iostream>
#include <thread>

// Class with a non-static member function
class Base {
public:
    void run(int x) {
        while (x-- > 0) {
            std::cout << x << std::endl;
        }
    }
};

int main() {
    Base b;
    // Create a thread using a non-static member function
    std::thread t(&Base::run, &b, 10);
    t.join(); // Wait for the thread to finish
    return 0;
}

Explanation:

• Base is a class with a member function run.
• std::thread t(&Base::run, &b, 10); creates a thread that runs the run function of the Base object b with the argument 10.

5. Static Member Function

Static member functions do not need an instance of a class to be called; they can be invoked directly without creating an object.

Example:

#include <iostream>
#include <thread>

// Class with a static member function
class Base {
public:
    static void run(int x) {
        while (x-- > 0) {
            std::cout << x << std::endl;
        }
    }
};

int main() {
    // Create a thread using a static member function
    std::thread t(&Base::run, 10);
    t.join(); // Wait for the thread to finish
    return 0;
}

Explanation:

• Base is a class with a static member function run.
• std::thread t(&Base::run, 10); creates a thread that runs the static run function with the argument 10.

Conclusion

These five methods offer flexibility for creating threads in C++11. Depending on your specific needs, you can select the most appropriate approach.

When creating multiple threads at the same time, there is no guarantee that one will start before the others. Happy threading!

---

I hope this makes the concepts clearer and easier to understand! If you have any more questions or need further assistance, feel free to ask.