c++11

#define _SILENCE_TR1_NAMESPACE_DEPRECATION_WARNING 
#include<iostream>
#include <array>
#include<string>
#include <functional>
using namespace std;
void fun(array<int,10> &a)
{
    int i = 0;
    for (auto element : a)
    {
        a[i++] += 1;
        cout << element;
    }
}

int main()
{

    array<int,10> a{1,2,3};
    a.front() = 4;
    a.operator[](1) = 9;
    fun(std::ref(a));
    for (auto a1 : a)
    {
        cout << a1;
    }
    string f = "hello";
    //for(auto i:f)
    //{
    //  cout << i;
    //}
    for (char value : f)
    {
        value += 1;
        cout << value;
    }
//  logical_or<>();
    logical_or<int> result;

    int ch[10];
    try
    {
        for (int& ch1 : ch)
        {
            cin >> ch1;
        }
    }
    catch (const exception& e)
    {
        cout << e.what();
    }   //}
    for (int ch1 : ch)
    {
        cout << ch1;
    }


}
int mian()
{

    return 0;
}


// ConsoleApplication1.cpp : 此文件包含 "main" 函数。程序执行将在此处开始并结束。
//#include <iostream>
//#include <type_traits>
//
//template <class T>
//struct Number { T n; };
//
//template <class T, class U>
//Number<typename std::common_type<T, U>::type> operator+(const Number<T>& lhs,
//    const Number<U>& rhs)
//{
//    return { lhs.n + rhs.n };
//}
//
//int main()
//{
//    Number<int> i1 = { 1 }, i2 = { 2 };
//    Number<double> d1 = { 2.3 }, d2 = { 3.5 };
//    std::cout << "i1i2: " << (i1 + i2).n << "\ni1d2: " << (i1 + d2).n << '\n'
//        << "d1i2: " << (d1 + i2).n << "\nd1d2: " << (d1 + d2).n << '\n';
//}
// Compile using cl.exe /EHsc
// common_type sample
#include <iostream>
#include <type_traits>

struct Base {};
struct Derived : Base {};

int main()
{
    typedef std::common_type<unsigned char, short, int>::type NumericType;
    typedef std::common_type<float, double>::type FloatType;
    typedef std::common_type<const int, volatile int>::type ModifiedIntType;
    typedef std::common_type<Base, Derived>::type ClassType;

    std::cout << std::boolalpha;
    std::cout << "Test for typedefs of common_type int" << std::endl;
    std::cout << "NumericType: " << std::is_same<int, NumericType>::value << std::endl;
    std::cout << "FloatType: " << std::is_same<int, FloatType>::value << std::endl;
    std::cout << "ModifiedIntType: " << std::is_same<int, ModifiedIntType>::value << std::endl;
    std::cout << "ClassType: " << std::is_same<int, ClassType>::value << std::endl;
    std::cout << "---------------------------" << std::endl;
    std::cout << "Test for typedefs of common_type double" << std::endl;
    std::cout << "NumericType: " << std::is_same<double, NumericType>::value << std::endl;
    std::cout << "FloatType: " << std::is_same<double, FloatType>::value << std::endl;
    std::cout << "ModifiedIntType: " << std::is_same<double, ModifiedIntType>::value << std::endl;
    std::cout << "ClassType: " << std::is_same<double, ClassType>::value << std::endl;
    std::cout << "---------------------------" << std::endl;
    std::cout << "Test for typedefs of common_type Base" << std::endl;
    std::cout << "NumericType: " << std::is_same<Base, NumericType>::value << std::endl;
    std::cout << "FloatType: " << std::is_same<Base, FloatType>::value << std::endl;
    std::cout << "ModifiedIntType: " << std::is_same<Base, ModifiedIntType>::value << std::endl;
    std::cout << "ClassType: " << std::is_same<Base, ClassType>::value << std::endl;

    return 0;
}

//// ConsoleApplication2.cpp : 此文件包含 "main" 函数。程序执行将在此处开始并结束。
////
//#include <functional>
//#include <vector>
//#include <iostream>
//template<typename T>
//void foo(T val)
//{
//
//std:: cout << val;
//
//}
//
//
//
//
//
//int main()
//{
//  void fun(int x, int y);
//  std::vector<std::function<void(int, int)>> ta;
//  ta.push_back(fun);
//  ta.push_back([](int x, int y)
//      {
//          std::cout << x;
//      });
//  for(std::function<void(int,int)> f:ta)
//  {
//      f(33, 45);
//  }
//  int x{3};
//  foo(std::ref(x));
//}

#include <iostream>
#include <functional>
#include <vector>
#include <algorithm>
void fun(int x, int y)
{
    std::cout << "fun: " << x << ", " << y << std::endl;
}
bool int_ptr_less(int *a,int *b)
{
    return *a  < *b;

}
class c
{
public:
    void mfunc(int x, int y) const
    {
        std::cout << "fun: " << x << ", " << y << std::endl;
    }
};

auto divide(int a, int b) -> decltype((double)a/b) {
    if (b != 0) {
        return static_cast<double>(a) / b;
    }
    else {
        throw std::invalid_argument("Division by zero");
    }
}

int main()
{
    std::vector<std::function<void(int, int)>> ta;
    ta.push_back(fun);
    ta.push_back([](int x, int y)
    {
        std::cout << "Lambda: " << x << y << std::endl;
    });

    for (std::function<void(int, int)> f : ta)
    {
        f(33, 45);
    }

    std::function<void(const c&, int, int)> mf;
    mf = &c::mfunc;
    mf(c(), 34, 34);


    int x = 17;
    int y = 42;
    int z = 33;
    int* px = &x;
    int* py = &y;
    int* pz = &z;
    int* pmax = std::max(px, py, int_ptr_less);


    std::pair<int*, int*> ex = std::minmax({ px,py,pz }, int_ptr_less);//first 17 second 42


    auto ex1 = std::minmax({ px,py,pz }, [](int*a,int*b)
    {
            return *a > *b;
    });

    int bz = 10;
    decltype(bz) fz = 10;
    std::cout << fz;
    auto i=divide(32, 4);
   return 0;
}
// ConsoleApplication3.cpp : 此文件包含 "main" 函数。程序执行将在此处开始并结束。
//

#include <iostream>  
#include <thread>  
#include <atomic>  
#include <chrono>  

std::atomic<bool> ready(false); // 初始化为 false 的原子布尔变量  

void workerThread() {
    std::this_thread::sleep_for(std::chrono::seconds(1));
    ready.store(true); // 设置 ready 为 true，通知其他线程  
    std::cout << "Worker thread finished its work.\n";
}

int main() {
    std::thread t(workerThread);
    t.detach();
    while (!ready.load()) {
        std::cout << "Waiting for the worker thread to finish...\n";
        std::this_thread::sleep_for(std::chrono::milliseconds(100)); // 等待 worker 线程完成  
    }

    std::cout << "Main thread detected that the work is ready.\n";
    //t.join();
    return 0;
}
// ConsoleApplication24.cpp : 此文件包含 "main" 函数。程序执行将在此处开始并结束。
//

#include <iostream>

template<typename T>
void foo(const T& val)
{

    if(std::is_pointer<T>::value)
    {

        std::cout << "pointer";
    }
    else
    {
        std::cout << "value";
    }

}
template <typename T>
void foo_impl(const  T& val, std::true_type)
{
    std::cout << *val << std::endl;
}

template <typename T>
void foo_impl(const T& val, std::false_type)
{
    std::cout << val << std::endl;
}

template <typename T>
void foo_(const T& val)
{
    foo_impl(val, std::is_pointer<T>());
}
template <>
void foo_impl(const int& val, std::false_type)
{
    std::cout << "not int" << std::endl;
}

template <>
void foo_impl(const  int& val, std::true_type)
{
    std::cout <<val << std::endl;
}
template <typename T>
void foo1_(const T& val)
{
    foo_impl(val, std::is_integral<T>());
}
//
//template<typename T1,typename T2>
//struct commmon_type<T1,T2>
//{
//    typedef decltype(true ? std::declval<T1>() : std::declval<T2>()) type;
//};
template<typename T1,typename T2>
typename std::common_type<T1, T2>::type min(const T1& x, const T2& y);

int main()
{
    foo<int>(2);
    std::cout << "\n";
    const char* p = "hello";
    foo<const char*>(p);
    std::cout << "\n";

    foo_<const char*>(p);
    std::cout << "\n";
    foo1_<int>(2);
    std::cout << "Hello World!\n";
    foo1_(2.4);
   // commmon_type<std::string,const char*> f;
    long f = 9;
    //min(2, f);
   // min<int, long>(2, 8);
    const char* s = "hello";
    std::string str=s;
    //const char* ss = str;
    std::cout << str;
}
// ConsoleApplication4.cpp : 此文件包含 "main" 函数。程序执行将在此处开始并结束。
//
#include <iterator>
#include<algorithm>
#include <functional>
#include<string>
#include <iostream>
#include <vector>
using namespace std;
template<typename T>
inline void PRINT_ELMENT(const T& coll)
{
    for(const auto elem:coll)
    {
        cout << elem<<"\n";
    }
}
void fun(int a)
{
    cout << a;

}

int main()
{
    vector<string> cotainer;

    ////input still you are  enter ctrl+c
    //copy(istream_iterator<string>(cin), istream_iterator<string>(), back_inserter(cotainer));
    //sort(cotainer.begin(), cotainer.end());
    //unique_copy(cotainer.begin(), cotainer.end(), ostream_iterator<string>(cout, ","));
    int i = 90;
    bind(fun, 1)();
    bind(fun, ref(i))();
    vector<int> f{ 1,2,3,4,5 };

    iter_swap(f.begin(), prev(f.end()));
    for(auto i:f)
    {
        cout << i;
    }

}


#include <iostream>                // std::cout

#include <thread>                // std::thread

#include <mutex>                // std::mutex, std::unique_lock

#include <condition_variable>    // std::condition_variable



std::mutex mtx; // 全局互斥锁.

std::condition_variable cv; // 全局条件变量.

bool ready = false; // 全局标志位.



void do_print_id(int id)

{

    std::unique_lock <std::mutex> lck(mtx);

    while (!ready) // 如果标志位不为 true, 则等待...

        cv.wait(lck); // 当前线程被阻塞, 当全局标志位变为 true 之后,

    // 线程被唤醒, 继续往下执行打印线程编号id.

    std::cout << "thread " << id << '\n';

}



void go()

{

    std::unique_lock <std::mutex> lck(mtx);

    ready = true; // 设置全局标志位为 true.

    cv.notify_all(); // 唤醒所有线程.

}



int main()

{

    std::thread threads[10];

    // spawn 10 threads:

    for (int i = 0; i < 10; ++i)

        threads[i] = std::thread(do_print_id, i);



    std::cout << "10 threads ready to race...\n";

    go(); // go!



    for (auto& th : threads)

        th.join();



    return 0;

}

// ConsoleApplication25.cpp : 此文件包含 "main" 函数。程序执行将在此处开始并结束。
//
#include <future>
#include <iostream>
#include <random>
#include <thread>
using namespace std;
int dosomething(char c)
{
    default_random_engine dre(c);
    uniform_int_distribution<int> id(10, 1000);
    for(int i=0;i<10;++i)
    {
        this_thread::sleep_for(chrono::milliseconds(id(dre)));
        cout.put(c).flush();
    }
    return c;
}
int fun1()
{
    return dosomething('-');
}
int fun2()
{
    return dosomething('+');
}
int main()
{
    std::cout << "Hello World!\n";
    std::future<int> result1(std::async(fun1));
    int result2 = fun2();
    int result = result1.get() + result2;
   // cout <<( result1 + result2);
    cout << result;
}