7 Essential C++ Concepts for Every Developer

// C++ program to demonstrate the use of pointers

#include <iostream>
using namespace std;

int main()
{
    // define ab variable num
    int num = 10;
    // Pointer to int, storing the address  of num
    int* ptr = &num;

    // Dereferencing ptr to get the value at that memory
    // address
    cout << "Value of num: " << *ptr << endl;
    return 0;
}

// C++ program to demonstrate OOP Principles

#include <iostream>
using namespace std;

// Define a base class named MyClass.
class MyClass {
public:
    // Member function to print a message.
    void myMethod()
    {
        cout << "Hello from MyClass!" << endl;
    }
};

// Define a derived class named MyClass2 that inherits from
// MyClass.
class MyClass2 : public MyClass {
public:
    // Member function to print a different message.
    void myMethod2()
    {
        cout << "Hello from MyClass2" << endl;
    }
};

int main()
{
    // Create an object of MyClass.
    MyClass obj;
    // Create an object of MyClass2.
    MyClass2 obj2;
    // Call the myMethod() of MyClass using obj.
    obj.myMethod();
    // Call the myMethod2() of MyClass2 using obj2.
    obj2.myMethod2();
    // Call the myMethod() of MyClass using obj2.
    obj2.myMethod();

    return 0;
}

// C++ program to demonstrate overloading

#include <iostream>
using namespace std;

// Define a class named Print.
class Print {
public:
    // Member function to display an integer value.
    void display(int i)
    {
        cout << "Integer: " << i << endl;
    }

    // Member function to display a double value.
    void display(double d)
    {
        cout << "Double: " << d << endl;
    }
};

int main()
{
    // Create an object of the Print class.
    Print obj;

    // Call the display function with an integer argument.
    obj.display(5);

    // Call the display function with a double argument.
    obj.display(10.5);

    return 0;
}

// C++ program to demonstrate container in STL

#include <algorithm>
#include <iostream>
#include <vector>
using namespace std;

int main()
{
    // Initialize a vector of integers with some values.
    vector<int> nums = { 5, 2, 8, 1, 9 };

    // Sort the vector in ascending order using the standard
    // library sort function.
    sort(nums.begin(), nums.end());

    // Print the sorted vector elements.
    cout << "Vector Elements: ";
    for (auto it : nums) {
        cout << it << " ";
    }
    cout << endl;

    // Find and print the maximum element in the vector
    // using the standard library max_element function.
    cout << "Max element: "
         << *max_element(nums.begin(), nums.end()) << endl;

    return 0;
}

// C++ program to demonstrate dynamic memory allocation and
// deallocation

#include <iostream>
using namespace std;

int main()
{
    // Dynamic memory allocation
    int* ptr = new int;
    *ptr = 5;
    // print he value of ptr
    cout << "Value at ptr: " << *ptr << endl;

    // Deallocate memory
    delete ptr;
    return 0;
}

// C++ program to demonstrate exception handling

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

int main()
{
    try {
        // Declare and initialize two integers.
        int x = 10, y = 0;

        // Check if the divisor is zero.
        if (y == 0)
            // Throw a runtime error exception if divisor is
            // zero.
            throw runtime_error("Divide by zero error");

        // Perform division and print the result (this line
        // won't execute if y is zero).
        cout << "Result: " << x / y << endl;
    }
    catch (const runtime_error& e) {
        // Catch the runtime error exception and print the
        // error message.
        cout << "Exception caught: " << e.what() << endl;
    }

    return 0;
}

// C++ program to demonstrate the concurrency

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

// Function to be executed by the new thread.
void threadFunction()
{
    cout << "Hello from thread!" << endl;
}

int main()
{

    // Create a new thread that runs the threadFunction.
    thread t(threadFunction);

    // Wait for the thread t to finish its execution.
    t.join();

    // Print a message from the main thread.
    cout << "Main thread" << endl;

    return 0;
}