User Tools

Site Tools


Old-old-old

init.cpp
#include <iostream>
 
using namespace std;
 
class foo_c {
    public:
        uint        i;
        string      s;
};
 
 
int main(int argc, char **argv) {
    foo_c foo;
 
    cout << foo.i << endl;
    cout << foo.s << endl;
 
    return 0;
}

Out

4294961080
parentn.cpp
#include <iostream>
 
using namespace std;
 
class parent_t {
    public:
        parent_t() {
            cout << "#parent init" << endl;
        }
        friend ostream& operator<<(ostream &out, const parent_t &p) {
            return p.print(out);
        }
        virtual ostream& print(ostream& out) const {
            out << "#parent out";
            return out;
        }
        virtual void print1() {
            cout << "#parent virt" << endl;
        }
 
        void print2() {
            cout << "#parent nonvirt" << endl;
        }
        virtual ~parent_t() {
            cout << "#parent destroy" << endl;
        }
};
 
class child_t: public parent_t {
    public:
        child_t() {
            cout << "#child init" << endl;
        }
        virtual ostream& print(ostream& out) const override {
            out << "#child out";
            return out;
        }
        virtual void print1() override {
            cout << "#child virt" << endl;
        }
 
        void print2() {
            cout << "#child novirt" << endl;
        }
        virtual ~child_t() {
            cout << "#child destroy" << endl;
        }
};
 
int main(int argc, char **argv) {
    cout << "##  start0" << endl;
    child_t child;
 
    //parent_t *parent;
    //parent = &child;
    //cout << *parent << endl;
 
    //parent_t* parent = new parent_t;
    //delete parent;
    //parent = &child;
    //cout << *parent << endl;
    //cout << "#end" << endl;
 
    child_t *child2;
    child2 = &child;
    cout << "##  start1" << endl;
 
    child2->print1();
    child2->print2();
 
    cout << "##  start2" << endl;
 
    parent_t *parent;
    parent = &child;
    parent->print1();
    parent->print2();
 
    cout << "##end" << endl;
 
    return 0;
}
 
//$ ./parentn
 
//##  start0
//#parent init
//#child init
 
//##  start1
//#child virt
//#child novirt
 
//##  start2
//#child virt
//#parent nonvirt
 
//##end
//#child destroy
//#parent destroy

Out

##  start0
#parent init
#child init
##  start1
#child virt
#child novirt
##  start2
#child virt
#parent nonvirt
##end
#child destroy
#parent destroy
ref.cpp
#include <iostream>
 
using namespace std;
 
int main(int argc, char **argv) {
 
    int i = 1;
    int& n = i;
    int* m = &i;
 
    i = 3;
 
    cout << i << endl;
    cout << n << endl;
    cout << *m << endl;
 
    cout << &i << endl;
    cout << &n << endl;
    cout << m << endl;
    cout << &m << endl;
 
    //int x=5, y=7, z=8;
    //int arr[] {x, y, z};    // error: declaration of 'arr' as array of references
 
 
    return 0;
}

Out

3
3
3
0x7fffffffe72c
0x7fffffffe72c
0x7fffffffe72c
0x7fffffffe718
smartp.cpp
#include <iostream>
 
using namespace std;
 
class foo_t {
    public:
        foo_t() {
            cout << "#foo init" << endl;
        }
        friend ostream& operator<<(ostream &out, const foo_t &p) {
            return p.print(out);
        }
        virtual ostream& print(ostream& out) const {
            out << "#foo out";
            return out;
        }
        virtual void print() {
            cout << "#foo out" << endl;
        }
        virtual ~foo_t() {
            cout << "#foo destroy" << endl;
        }
};
 
 
template <typename T>
class smart_pointer {
        T *m_obj;
    public:
        smart_pointer(T *obj)
            : m_obj(obj)
        { }
        ~smart_pointer() {
            delete m_obj;
        }
        T* operator->() {
            return m_obj;
        }
        T& operator* () {
            return *m_obj;
        }
};
 
 
void printer(foo_t *foo) {
    foo->print();
}
void printer(smart_pointer<foo_t> foo) {
    foo->print();
}
 
 
int main(int argc, char **argv) {
    cout << "#start" << endl;
 
    //auto foo = new foo_t;
    //cout << *foo << endl;
    //printer(foo);
 
    smart_pointer<foo_t> foo_p(new foo_t());
    printer(foo_p);
 
    cout << "#end" << endl;
 
    return 0;
}
 
/*
 
$ ./smartp
#start
#foo init
#foo out
#foo destroy
#end
#foo destroy
 * /

Out


smartp2.cpp
#include <iostream>
 
using namespace std;
 
class foo_t {
    public:
        foo_t() {
            cout << "#foo init" << endl;
        }
        friend ostream& operator<<(ostream &out, const foo_t &p) {
            return p.print(out);
        }
        virtual ostream& print(ostream& out) const {
            out << "#foo out";
            return out;
        }
        virtual void print() {
            cout << "#foo out" << endl;
        }
        virtual ~foo_t() {
            cout << "#foo destroy" << endl;
        }
};
 
 
template <typename T>
class smart_pointer {
        T *m_obj;
    public:
        smart_pointer(T *obj)
            : m_obj(obj)
        { }
        ~smart_pointer() {
            delete m_obj;
        }
        T* operator->() {
            return m_obj;
        }
        T& operator* () {
            return *m_obj;
        }
};
 
 
void printer(foo_t *foo) {
    foo->print();
}
void printer(smart_pointer<foo_t> foo) {
    foo->print();
}
 
 
int main(int argc, char **argv) {
    cout << "#start" << endl;
 
    //auto foo = new foo_t;
    //cout << *foo << endl;
    //printer(foo);
 
    smart_pointer<foo_t> foo_p(new foo_t());
    //printer(foo_p);
 
    cout << "#end" << endl;
 
    return 0;
}
 
/*
 
$ ./smartp
#start
#foo init
#foo out
#foo destroy
#end
#foo destroy
 */

Out

#start
#foo init
#end
#foo destroy
stream.cpp
#include <iostream>
 
using namespace std;
 
template <typename T>
class smart_pointer {
        T *m_obj;
    public:
        smart_pointer(T *obj)
            : m_obj(obj)
        { }
        ~smart_pointer() {
            delete m_obj;
        }
        T* operator->() {
            return m_obj;
        }
        T& operator* () {
            return *m_obj;
        }
};
 
//int test {
    //smart_pointer<MyClass> pMyClass(new MyClass(/*params*/);
    //pMyClass->something();
    //std::cout << *pMyClass << std::endl;
//}
 
class parent_t {
    public:
        parent_t() {
            cout << "#parent init" << endl;
        }
        friend ostream& operator<<(ostream &out, const parent_t &p) {
            return p.print(out);
        }
        virtual ostream& print(ostream& out) const {
            out << "#parent out";
            return out;
        }
        ~parent_t() {
            cout << "#parent destroy" << endl;
        }
};
 
class child_t: public parent_t {
    public:
        child_t() {
            cout << "#child init" << endl;
        }
        virtual ostream& print(ostream& out) const override {
            out << "#child out";
            return out;
        }
        virtual ~child_t() {
            cout << "#child destroy" << endl;
        }
};
 
 
int main(int argc, char **argv) {
    cout << "#start" << endl;
    child_t child;
 
    //parent_t *parent;
    //parent = &child;
    //cout << *parent << endl;
 
    parent_t parent;
    parent = child;
    cout << parent << endl;
    cout << "#end" << endl;
 
    return 0;
}

Out

#start
#parent init
#child init
#parent init
#parent out
#end
#parent destroy
#child destroy
#parent destroy
thpool.cpp
#include <iostream>
#include <thread>
#include <mutex>
#include <condition_variable>
#include <atomic>
#include <chrono>
 
 
using namespace std;
using namespace std::chrono;
using namespace std::this_thread;
 
class worker_t {
    private:
        mutex loop_mtx;
        condition_variable loop_cv;
        mutex exec_mtx;
        condition_variable exec_cv;
        atomic<bool> loop_ready{false};
        atomic<bool> exec_ready{false};
        atomic<bool> stop{false};
        float input;
        float result;
    public:
        float exec(float i) {
            input = i;
            loop_ready = true;
            loop_cv.notify_one();
 
            unique_lock<mutex> ul(exec_mtx);
            while (!exec_ready.load()) exec_cv.wait(ul);
 
            cout << "exec done" << endl;
 
            exec_ready = false;
            ul.unlock();
        }
        void kill() {
            stop = true;
            loop_ready = true;
            loop_cv.notify_one();
        }
        void loop() {
            while(true) {
                unique_lock<mutex> ul(loop_mtx);
                while (!loop_ready.load()) loop_cv.wait(ul);
                if (stop.load()) return;
 
                cout << "loop start" << endl;
                result = i * i;
 
                exec_ready = true;
                exec_cv.notify_one();
                loop_ready = false;
                ul.unlock();
            }
        }
};
 
int main(int argc, char **argv) {
 
    worker_t worker;
    thread th1(&worker_t::loop, &worker);
 
    auto f = [worker = &worker](){
        //sleep_for(milliseconds(2000));
        cout << "go" << endl;
        worker->exec(1);
        cout << "go" << endl;
        worker->exec(2);
        worker->kill();
    };
    thread th2(f);
    th1.join();
    th2.join();
 
    return 0;
}

Out


thread04.cpp
#include <iostream>
#include <chrono>
#include <thread>
 
using namespace std;
using namespace std::this_thread;
using namespace std::chrono;
 
 
typedef struct {
    string id;
    string message;
} pth_args_t;
 
void *pth(void *args) {
    auto pth_args = (pth_args_t*)args;
    sleep_for(milliseconds(1000));
    cout << "#pth " << pth_args->id << endl;
    sleep_for(milliseconds(1000));
    cout << "#pth " << pth_args->message << endl;
    pthread_exit(0);
}
 
 
int main(int argc, char **argv) {
 
    pthread_attr_t pth_attr;
    pthread_t pth_id;
 
    pth_args_t pth_args;
    pth_args.id         = "001";
    pth_args.message    = "hi";
 
    pthread_attr_init(&pth_attr);
    pthread_create(&pth_id, &pth_attr, pth, (void *)&pth_args);
    pthread_join(pth_id, NULL);
 
    return 0;
}

Out

#pth 001
#pth hi
thread05.cpp
#include <iostream>
#include <chrono>
#include <thread>
#include <mutex>
 
using namespace std;
using namespace std::this_thread;
using namespace std::chrono;
 
class pth_args_c {
    private:
        string id   = "";
        string msg  = "";
        mutex msg_mutex;
    public:
        pth_args_c(string id) {
            this->id = id;
        };
        string get_id() {
            return this->id;
        }
        void set_msg(string msg) {
            this->msg = msg;
        }
        string get_msg() {
            return this->msg;
        }
};
 
void *pth(void *args) {
    auto pth_args = (pth_args_c*)args;
    sleep_for(milliseconds(1000));
    cout << "#pth " << pth_args->get_id() << endl;
    sleep_for(milliseconds(1000));
    cout << "#pth " << pth_args->get_msg() << endl;
    pthread_exit(0);
}
 
int main(int argc, char **argv) {
 
    pthread_attr_t pth_attr;
    pthread_t pth_id;
 
    pth_args_c pth_args("01");
    pth_args.set_msg("hi");
 
    pthread_attr_init(&pth_attr);
    pthread_create(&pth_id, &pth_attr, pth, (void *)&pth_args);
    pthread_join(pth_id, NULL);
 
    return 0;
}

Out

#pth 01
#pth hi
thread06.cpp
#include <iostream>
#include <chrono>
#include <thread>
#include <mutex>
 
using namespace std;
using namespace std::this_thread;
using namespace std::chrono;
 
class pth_args_c {
    private:
        string id   = "";
        string msg  = "";
        mutex msg_mutex;
    public:
        pth_args_c(string id) {
            this->id = id;
        };
        string get_id() {
            return this->id;
        }
        void set_msg(string msg) {
            const lock_guard<mutex> lock(this->msg_mutex);
            this->msg = msg;
        }
        string get_msg() {
            return this->msg;
        }
};
 
void pth1(pth_args_c &pth_args) {
    sleep_for(milliseconds(5000));
    cout << "#pth " << pth_args.get_id() << endl;
    sleep_for(milliseconds(5000));
    cout << "#pth " << pth_args.get_msg() << endl;
}
 
void pth2(pth_args_c &pth_args) {
    sleep_for(milliseconds(1000));
    cout << "#pth " << pth_args.get_id() << endl;
    sleep_for(milliseconds(1000));
    cout << "#pth " << pth_args.get_msg() << endl;
}
 
 
int main(int argc, char **argv) {
 
    pth_args_c pth1_args("01");
    pth1_args.set_msg("hi1");
 
    pth_args_c pth2_args("02");
    pth2_args.set_msg("hi2");
 
 
    thread pthr1(pth1, ref(pth1_args));
    thread pthr2(pth2, ref(pth2_args));
 
    pthr1.join();
    cout << "#wait" << endl;
    pthr2.join();
 
    return 0;
}
//EOF

Out

#pth 02
#pth hi2
#pth 01
#pth hi1
#wait
thread07.cpp
#include <iostream>
#include <chrono>
#include <thread>
#include <mutex>
#include <vector>
#include <memory>
 
using namespace std;
using namespace std::this_thread;
using namespace std::chrono;
 
class worker_t {
    private:
        int id      = 0;
        string msg  = "";
        mutex msg_mutex;
    public:
        worker_t(int id)  {
            this->id = id;
        };
        int get_id() {
            return this->id;
        }
        void set_msg(string msg) {
            const lock_guard<mutex> lock(this->msg_mutex);
            this->msg = msg;
        }
        void prn_msg() {
            const lock_guard<mutex> lock(this->msg_mutex);
            cout << "#pth "
                << this->id
                << " "
                << this->msg
                << endl;
        }
        string get_msg() {
            return this->msg;
        }
        virtual ~worker_t() {
            cout << "#worker destroy" << endl;
        }
};
 
void pth(shared_ptr<worker_t> worker) {
    //sleep_for(milliseconds(500));
    worker->prn_msg();
}
 
int main(int argc, char **argv) {
 
    vector<thread> ptrs;
    vector<shared_ptr<worker_t>> workers;
 
    for (auto i: { 1,2,3,4,5 }) {
        auto worker = make_shared<worker_t>(i);
        workers.push_back(worker);
    }
    for (auto worker: workers) {
        ptrs.push_back(thread(pth, worker));
    }
    for (auto &thread: ptrs) {
            thread.join();
    }
    cout << "#wait" << endl;
    return 0;
}
//EOF

Out

#pth #pth 1#pth  3#pth  

5 
#pth 4 
2 
#wait
#worker destroy
#worker destroy
#worker destroy
#worker destroy
#worker destroy
thread08.cpp
 
#include <iostream>
#include <chrono>
#include <thread>
#include <mutex>
#include <vector>
#include <memory>
 
#include <chrono>
 
using namespace std;
using namespace std::this_thread;
using namespace std::chrono;
 
void pthread(float value, shared_ptr<float> result) {
    *result = value * value;
}
 
int main(int argc, char **argv) {
 
    vector<thread> threads;
    vector<shared_ptr<float>> results;
 
    auto start = high_resolution_clock::now();
 
    for (int i = 1; i < 1000; i++) {
        auto result = make_shared<float>();
        results.push_back(result);
    }
    float i = 1;
    for (auto result: results) {
        threads.push_back(thread(pthread, i++, result));
 
    }
    for (auto &thread: threads) {
            thread.join();
    }
    for (auto result: results) {
        //cout << *result << endl;
    }
    auto stop = high_resolution_clock::now();
    auto duration = duration_cast<microseconds>(stop - start);
 
    cout << "#wait " << duration.count() << endl;
    return 0;
}
//EOF

Out

#wait 111811
twork2.cpp
#include <iostream>
#include <thread>
#include <mutex>
#include <condition_variable>
#include <atomic>
#include <chrono>
 
 
using namespace std;
using namespace std::chrono;
using namespace std::this_thread;
 
class worker_t {
    private:
        mutex loop_mtx;
        condition_variable loop_cv;
        mutex exec_mtx;
        condition_variable exec_cv;
        atomic<bool> loop_ready{false};
        atomic<bool> exec_ready{false};
        atomic<bool> stop{false};
        float input;
        float result;
    public:
        float exec(float i) {
            input = i;
            loop_ready = true;
            loop_cv.notify_one();
 
            unique_lock<mutex> ul(exec_mtx);
            while (!exec_ready.load()) exec_cv.wait(ul);
 
            cout << "exec done" << endl;
 
            exec_ready = false;
            ul.unlock();
        }
        void kill() {
            stop = true;
            loop_ready = true;
            loop_cv.notify_one();
        }
        void loop() {
            while(true) {
                unique_lock<mutex> ul(loop_mtx);
                while (!loop_ready.load()) loop_cv.wait(ul);
                if (stop.load()) return;
 
                cout << "loop start" << endl;
                result = i * i;
 
                exec_ready = true;
                exec_cv.notify_one();
                loop_ready = false;
                ul.unlock();
            }
        }
};
 
int main(int argc, char **argv) {
 
    worker_t worker;
    thread th1(&worker_t::loop, &worker);
 
    auto f = [worker = &worker](){
        //sleep_for(milliseconds(2000));
        cout << "go" << endl;
        worker->exec(1);
        cout << "go" << endl;
        worker->exec(2);
        worker->kill();
    };
    thread th2(f);
    th1.join();
    th2.join();
 
    return 0;
}

Out


twork3.cpp
#include <iostream>
#include <mutex>
#include <vector>
#include <thread>
 
using namespace std;
 
class exec_t {
    private:
        mutex exec_mtx;
    public:
        float exec(float i)  {
            lock_guard<mutex> lock(exec_mtx);
            auto res = i * i;
            cout << res << endl;
            return res;
        }
};
 
void starter(exec_t& exec, float i) {
    exec.exec(i);
}
 
 
int main(int argc, char **argv) {
 
    exec_t exec;
    vector<thread> threads;
 
    for (auto i: { 1,2,3,4,5,6,7,8 }) {
        threads.push_back(thread(starter, ref(exec), (float)i));
    }
    for (auto &thread: threads) {
            thread.join();
    }
    return 0;
}

Out

1
4
9
16
25
36
49
64