Intermediate CPP Programming

Data Structure

: Array, Vector, Queue, Stack, Heap, List, Map, Iterator, Generator, Tree, Graph

#include <iostream>
using namespace std;

int main(){
    int arr[] = {100, 200, 300, 400, 500};

    int i_start = 0;
    int i_end = static_cast<int>(sizeof(arr)/sizeof(arr[0]));
    for(int i=i_start; i<i_end; i++){
        cout << arr[i] << ' ';
    } cout << endl;

    int* ptr_start = &arr[0];
    int* ptr_end = &arr[0] + static_cast<ptrdiff_t>(sizeof(arr)/sizeof(arr[0]));
    for(int* ptr=ptr_start; ptr<ptr_end; ptr++){
        cout << *ptr << ' ';} cout << endl;
}

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

int main(){
    array<int, 5> sarr = {100, 200, 300, 400, 500};
    cout << *sarr.begin() << endl;
    cout << *sarr.end() << endl;

    int key = 0;
    for_each(sarr.begin(), sarr.end(), [&key](int value){
            cout << to_string(key++) + ", " + to_string(value) << endl;
            });

    for(auto value: sarr){
        cout << value << endl;
    }

    for(int key=0; key<sarr.size(); key++){
        cout << sarr[key] << endl;
    }

    for(int* it = sarr.begin(); it < sarr.end(); it++){
        cout << *it << endl;
    }

}

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

int main(){
    vector<int> darr = {100, 200, 300, 400, 500};
    cout << *darr.begin() << endl;
    cout << *darr.end() << endl;

    int key = 0;
    for_each(darr.begin(), darr.end(), [&key](int value){
            cout << to_string(key++) + ", " + to_string(value) << endl;
            });

    for(auto value: darr){
        cout << value << endl;
    }

    for(int key=0; key<darr.size(); key++){
        cout << darr[key] << endl;
    }

    for(vector<int>::iterator it = darr.begin(); it != darr.end(); it++){
        cout << *it << endl;
    }

}

 

 

Initializer List, Pair, Tuple and Variant, Any

Initializer List

#include <iostream>
using namespace std;

int main() {
    initializer_list<int> ilist = {1,2,3,4,5};
    for (const auto& val1 : ilist) {
        cout << val1 << endl;
    }

    return 0;
}

 

Pair

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

int main() {
    pair<int, std::string> pair_type(1, "text");

    cout << pair_type.first << endl;
    cout << pair_type.second << endl;

    return 0;
}

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

int main() {
    vector<pair<int, int>> container = {{1, 2}, {3, 4}, {5, 6}};

    for (auto& [val1, val2] : container) {
        cout << val1 << ", " << val2 << endl;
    }

    return 0;
}

Tuple

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

int main() {
    tuple<int, double, string> tuple_type(1, 3.14, "text");

    cout << get<0>(tuple_type) << endl;
    cout << get<1>(tuple_type) << endl;
    cout << get<2>(tuple_type) << endl;

    return 0;
}

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

int main() {
    vector<tuple<int, double, string>> container = {
        {1, 2.5, "apple"},
        {2, 3.6, "banana"},
        {3, 4.7, "cherry"}
    };

    for (const auto& [val1, val2, val3] : container) {
        cout << val1 << ", " << val2 << ", " << val3 << endl;
    }

    return 0;
}

 

Variant

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

int main(){
    variant<int, double, string> a = 1;
    variant<int, double, string> b = 3.14;
    variant<int, double, string> c = "text";

    cout << get<int>(a) << endl;
    cout << get<double>(b) << endl;
    cout << get<string>(c) << endl;
}

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

int main(){
    variant<int, double, string> a = 1;
    visit([](auto&& value) {
            cout << value << endl;
        }, a);

    variant<int, double, string> b = 3.14;
    visit([](auto&& value) {
            cout << value << endl;
        }, b);

    variant<int, double, string> c = "text";
    visit([](auto&& value) {
            cout << value << endl;
        }, c);
}

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

int main() {
    vector<variant<int, double, string>> container = {3.14, 0, "text"};
    
    for (const auto& item : container) {
        visit([](auto&& value) {
            cout << value << endl;
        }, item);
    }
}

 

Any

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

int main() {
    any a;
    a = 1;
    a = 3.14;
    a = "text";

    try{
        cout << any_cast<int>(a) << endl;
        cout << any_cast<double>(a) << endl;
        cout << any_cast<string>(a) << endl;
    }
    catch (const bad_any_cast& e){
        cout << e.what() << endl;
    }
}

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

int main() {
    vector<any> container = {3.14, 0, "text"};

    for (const auto& item : container) {
        if (item.type() == typeid(int)) {
            cout << any_cast<int>(item) << '\n';
        } else if (item.type() == typeid(double)) {
            cout << any_cast<double>(item) << '\n';
        } else if (item.type() == typeid(string)) {
            cout << any_cast<string>(item) << '\n';
        }
    }

}

 

 

Static and Dynamic Array

[Array]: Static Array; Stack Memory

1D Array

#include <iostream>
#include <string>
#include <utility>
#include <tuple>
#include <variant>
#include <any>
#include <array>
using namespace std;

int main() {
    array<pair<int, int>, 3> container1 = {
        pair<int, int>{1, 2},
        pair<int, int>{3, 4},
        pair<int, int>{5, 6}
    };
    array<tuple<int, double, string>, 3> container2 = {
        tuple<int, double, string>{1, 2.5, "apple"},
        tuple<int, double, string>{2, 3.6, "banana"},
        tuple<int, double, string>{3, 4.7, "cherry"}
    };
    array<variant<int, double, string>, 3> container3 = {
        variant<int, double, string>(3.14),
        variant<int, double, string>(0),
        variant<int, double, string>("text")
    };
    array<any, 3> container4 = {
        any(3.14),
        any(0),
        any("text")
    };

    return 0;
}

 

2D Array

//

 

[Vector]: Dynamic Array; Heap Memory

1D Vector

#include <iostream>
#include <string>
#include <utility>
#include <tuple>
#include <variant>
#include <any>
#include <vector>
using namespace std;

int main() {
    vector<pair<int, int>> container1 = {
        {1, 2},
        {3, 4},
        {5, 6}
    };
    vector<tuple<int, double, string>> container2 = {
        {1, 2.5, "apple"},
        {2, 3.6, "banana"},
        {3, 4.7, "cherry"}
    };
    vector<variant<int, double, string>> container3 = {
        3.14,
        0,
        "text"
    };
    vector<any> container4 = {
        3.14,
        0,
        "text"
    };
    
    return 0;
}

 

2D Vector

//

 

Generator and Iterator

For Loop

//

 

For Each Lambda Loop

//

 

 

Enumerator

#include <iostream>
#include <vector>
#include <utility> // for std::pair

// Enumerator class
template<typename Container>
class Enumerator {
public:
    // Constructor
    Enumerator(Container& container) : container_(container), index_(0) {}

    // Begin iterator
    class Iterator {
    public:
        Iterator(typename Container::iterator it, size_t index) : it_(it), index_(index) {}

        // Dereference operator
        std::pair<size_t, typename Container::value_type> operator*() const {
            return std::make_pair(index_, *it_);
        }

        // Increment operator
        Iterator& operator++() {
            ++it_;
            ++index_;
            return *this;
        }

        // Equality operator
        bool operator!=(const Iterator& other) const {
            return it_ != other.it_;
        }

    private:
        typename Container::iterator it_;
        size_t index_;
    };

    Iterator begin() {
        return Iterator(container_.begin(), 0);
    }

    Iterator end() {
        return Iterator(container_.end(), container_.size());
    }

private:
    Container& container_;
    size_t index_;
};

// Helper function to create an Enumerator
template<typename Container>
Enumerator<Container> enumerate(Container& container) {
    return Enumerator<Container>(container);
}

int main() {
    std::vector<std::string> vec = {"apple", "banana", "cherry"};

    for (auto [index, value] : enumerate(vec)) {
        std::cout << "Index: " << index << ", Value: " << value << std::endl;
    }

    return 0;
}

 

Iterator

#include <iostream>
using namespace std;

template <typename T>
class Iterator {
    T* ptr;

    public:
        Iterator(T* p=nullptr) : ptr(p) {}

        T& operator*() const {
            return *ptr;
        }

        T* operator->() const {
            return ptr;
        }

        Iterator& operator++() {
            ++ptr;
            return *this;
        }

        Iterator operator++(int) {
            Iterator temp = *this;
            ++(*this);
            return temp;
        }

        Iterator& operator--() {
            --ptr;
            return *this;
        }

        Iterator operator--(int) {
            Iterator temp = *this;
            --(*this);
            return temp;
        }
        
        ptrdiff_t operator-(const Iterator& other) const {
            return ptr - other.ptr;
        }

        Iterator operator+(ptrdiff_t n) const {
            return Iterator(ptr + n);
        }

        Iterator operator-(ptrdiff_t n) const {
            return Iterator(ptr - n);
        }

        Iterator& operator+=(ptrdiff_t n) {
            ptr += n;
            return *this;
        }

        Iterator& operator-=(ptrdiff_t n) {
            ptr -= n;
            return *this;
        }

        bool operator==(const Iterator& other) const {
            return ptr == other.ptr;
        }

        bool operator!=(const Iterator& other) const {
            return ptr != other.ptr;
        }

        bool operator<(const Iterator& other) const {
            return ptr < other.ptr;
        }

        bool operator<=(const Iterator& other) const {
            return ptr <= other.ptr;
        }

        bool operator>(const Iterator& other) const {
            return ptr > other.ptr;
        }

        bool operator>=(const Iterator& other) const {
            return ptr >= other.ptr;
        }
};        

int main() {
    int arr[] = {1, 2, 3, 4, 5};
    Iterator<int> begin(arr);
    Iterator<int> end(arr + 5);

    for (Iterator<int> it = begin; it != end; ++it) {
        std::cout << *it << " ";
    }

    return 0;
}

 

Generator

//

 

 

 

STL Container

[Queue]

//

 

[Stack]

//

 

[Heap]

//

 

[List]

#include <iostream>
#include <list>
#include <iterator>
#include <variant>
using namespace std;

int main() {
    list<int> container{1,2,3,4,5};
    for (const auto& i: container) {
        cout << i << endl;
    };

    return 0;
}

#include <iostream>
#include <list>
#include <iterator>
#include <variant>

using namespace std;

int main(){
    list<int> a;
    for(int i = 0; i < 10; i++) {a.push_back(i);};
    for(const auto& i: a) {
        cout << i << endl;
    }

    cout << *a.begin() << endl;
    cout << *a.end() << endl;

    return 0;
}

#include <iostream>
#include <list>
#include <iterator>
#include <variant>
using namespace std;

int main() {
    list<int> container{0,1,2,3,4,5,6,7,8,9};
    list<int>::iterator it = container.begin();

    cout << container.size() << endl;
    cout << container.empty() << endl;

    advance(it, 4); // *it : 4
    it = container.erase(it); // *it : 5
    it = container.erase(it); // *it : 6
    it = container.erase(it); // *it : 7
    container.insert(it, 4);  // *it : 7
    container.insert(it, 5);  // *it : 7
    container.insert(it, 6);  // *it : 7

    for (const auto& i: container) {
        cout << i << endl;
    };

    container.clear();
    return 0;
}

#include <iostream>
#include <list>
#include <iterator>
#include <variant>

using namespace std;

int main(){
        list<int> a;

        for(int i = 0; i < 10; i++) {
                a.push_back(i);
        }

        cout << *a.begin() << endl;
        cout << *a.end() << endl;

        return 0;
}

#include <iostream>
#include <list>
#include <iterator>
#include <variant>
using namespace std;

int main() {
    list<int> container{1,2,3,4,5};
    for (const auto& i: container) {
        cout << i << endl;
    };

    list<int> new_container;
    for (const auto& i: container) {
        new_container.push_back(i);
        new_container.pop_back();
    };

    for (const auto& i: container) {
        new_container.push_front(i);
        new_container.pop_front();
    };

    for (const auto& i: new_container) {
        cout << i << endl;
    };

    return 0;
}

 

[Map]

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

int main() {
    map<std::string, int> container;
    container["apple"] = 0;
    container["banana"] = 1;
    container["cat"] = 2;

    cout << container["apple"] << endl;
    cout << container["banana"] << endl;
    cout << container["cat"] << endl;

    return 0;
}

 

[Multimap]

//

 

[Tree]

//

 

[Graph]

//

 

 

 

---

Algorithm: Sort and Search

find_if

 

 

 

 

 

 

---

Memory: Process and Thread

cstdlib

//

 

 

 

---

Asynchronous Programming: Corutine

 

 

 

 

 

---

Design Pattern

 

 

 

 

 

 

 

 

 

---

Reference

• https://github.com/TheAlgorithms/C-Plus-Plus