template <typename Callable> class scope_exit {
   Callable ExitFunction;
   bool Engaged = true; // False once moved-from or release()d.
 
 public:
   template <typename Fp>
   explicit scope_exit(Fp &&F) : ExitFunction(std::forward<Fp>(F)) {}
 
   scope_exit(scope_exit &&Rhs)
       : ExitFunction(std::move(Rhs.ExitFunction)), Engaged(Rhs.Engaged) {
     Rhs.release();
   }
   scope_exit(const scope_exit &) = delete;
   scope_exit &operator=(scope_exit &&) = delete;
   scope_exit &operator=(const scope_exit &) = delete;
 
   void release() { Engaged = false; }
 
   ~scope_exit() {
     if (Engaged)
       ExitFunction();
   }
 };
 

  int r = memcmp(data_, b.data_, min_len);
  if (r == 0) {
    if (size_ < b.size_) r = -1;
    else if (size_ > b.size_) r = +1;
  }
  return r;

#define LOG(msg) \
    if (s_bLoggingEnabled) \
       std::cout<<__FILE__<<"("<<__LINE__<<")"<<msg<<std::endl;

using namespace std;
#define LOG(msg) \
    if (s_bLoggingEnabled) \
       (log(__FILE__,__LINE__,LogData<None>()<<msg));

template <typename List>
struct LogData{
    typedef List type;
    List list;
};
struct None{};

template <typename Begin, typename Value>
LogData<std::pair<Begin&&, Value&&>> operator<<(LogData<Begin>&& begin,
                                                Value&& v) noexcept {
    return ;
}

template <typename Begin, size_t n >
LogData<std::pair<Begin&&, const char* >> operator<<(LogData<Begin>&& begin,
                                               const char(&sz)[n]) noexcept{
    return ;
}

template<typename TLogData>
void log(const char* file, int line, TLogData&& data)
noexcept {
    std::cout<< file<<" "<<line<<": ";
    LogRecursive(std::cout, std::forward<typename TLogData::type>(data.list));
    std::cout<<std::endl;
}

template<typename TLogDataPair>
void LogRecursive(std::ostream& os, TLogDataPair&& data) noexcept{
   LogRecursive(os,std::forward<typename TLogDataPair::first_type>(data.first));
   os<<std::forward<typename TLogDataPair::second_type>(data.second);
}
inline void LogRecursive(std::ostream& os, None) noexcept{}

int main()
{
  s_bLoggingEnabled = true;
  string s{"blaa"};
  LOG("sth"<<s<<55<<"!!");
}

void callWithin(const std::function<void()>& fn){
    ScopedContext context;
    try{
        fn();
    } catch (SomeException& e){
        // handle exception here
    }
}

void printLine(const std::string& text){
    std::cout<<text<<'\n';
}
callWithin([](){printLine("Hello, CppCon");});

template <typename Callable>
void callWithin(const Callable& fn){
    ScopedContext context;
    fn();
}

double sum(double a,double b){return a+b;}
double res = callWithin([](){return sum(3.14,2.71);})

template <typename Callable> 
auto callWithin(const Callable& fn) ->decltype(fn()){
   decltype(fn()) result{};
   auto wrapperFn =[&]()->void
   {
       result = fn();
   }
   callWithImpl(wrapperFn);
   return result;
}
void callWithinImpl(const std::function<void()>& fn);

class Contextmanager{
public:
    virtual void callWithin(const std::function<void()>&fn) = 0;
};

class Contextmanager{
public:
  template <typename Fn>
  void callWithin(const Fn& fn, std::false_type) -> decltype(fn())
  {
    decltype(fn()) result{};
    callWithinImpl([&]{result=fn();});
    return result;
  }
private:
    virtual void callWithinImpl(const std::function<void()>&fn) = 0;
};

double result = manager->CallWithin([]{return sum(3.14, 2/71);});

template <typename Fn>
auto callWithin(const Fn& fn) -> decltype(fn())
{
    return _callWithin(fn, std::is_same<decltype(fn()),void>());
}
// true就直接调用，没有返回值
template <typename Fn>
void _callWithin(const Fn& fn, std::true_type) -> decltype(fn())
{
    callWithinImpl([&]{fn();});
}

template <typename Fn>
void _callWithin(const Fn& fn, std::false_type) -> decltype(fn())
{
    decltype(fn()) result{};
    callWithinImpl([&]{result=fn();});
    return result;
}

template <typename Fn>
void callWithin(const Fn& fn) -> std::optional<decltype(fn())>
{
    decltype(fn()) result{};
    bool ok = callWithinImpl([&]{result=fn();});
    if (ok)
    	return result;
    else
        return std::nullopt;
}

template <typenamet T>
void f(ParamType param);
f(expr);//  从expr推导T和ParamType

template <typename T>
void f(T& param);

int x=22;
const int cx = x;
const int& rx = x;
f(x); //  T = int,       param = int&
f(cx); // T = const int, param = const int&
f(rx); // T = const int, param = const int& 注意，此处的T ，expr是T& 直接忽略了&

template <typename T>
void f(const T& praam);

int x=22;
const int cx = x;
const int& rx = x;
f(x); //  T = int,       param = const int& 注意，此处的T ，expr是const T& 直接忽略了
f(cx); // T = const int, param = const int&
f(rx); // T = const int, param = const int& 

template <typename T>
void f(T* praam);

int x=22;
const int *pcx = &x;
f(&x);  //  T = int,       param = int *
f(pcx); //  T = const int, param = const int *

template <typename T>
void f(T&& param);
//f(expr)
int x = 22;
const int cx = x;
const int& rx = x;
f(x); //  T = int&,       param = int&
f(cx); // T = const int&, param = const int&
f(rx); // T = const int&, param = const int&   折叠了一个&
f(22); // T = int,        param = int&&  右值专属场景，完美转发

int x = 22;
const int cx = x;
const int& rx = x;

auto& v1 = x; //auto = int;
auto& v2 = cx; //auto = const int
auto& v3 = rx; // auto = const int
const auto& v4 = x; // auto = int
const auto& v5 = cx; // auto =int
const auto& v6 = rx; // auto =int
auto v7 = x;// auto =int
auto v8 = cx;// auto = int
auto v9 = rx;// auto = int
auto&& v10=rx;// type=const int&   左值，引用折叠了

void someFunc(const int* const param1,
              const int*       param2,
                    int*       param3)
{
    auto p1=param1;// auto = const int* 忽略了最后那个
    auto p2=param2;// const int*
    auto& p2v2=param2;// const int* const&，这个没忽略，注意区别
    auto p3=param3;// int*
}

template <typename T>
class TD;
template <typename T>
void f(T& param){
    TD<T> tType;
    TD<decltype(param)> paramType;
}

class C;
class SBRM{
    C* pc;
public:
    SBRM(C* c):pc(c){}
    ~SBRM(){delete pc;}
    operator C*(){return pc;}
};
...
for(int i=0; i<100; ++i){
   SBRM cc(new C(i)) ;
    C* c= cc;
    /*do sth about c*/
}

//没有SBRM管理是这样的
for(int i=0; i<100; ++i){
    C* c(new C(i)) ;
    /*do sth about c*/
    delete c;
}

struct Bad
{
    std::shared_ptr<Bad> getptr() {
        return std::shared_ptr<Bad>(this);
    }
    ~Bad() { std::cout << "Bad::~Bad() called\n"; }
};
{
    // Bad, each shared_ptr thinks it's the only owner of the object
    std::shared_ptr<Bad> bp1 = std::make_shared<Bad>();
    std::shared_ptr<Bad> bp2 = bp1->getptr();
    std::cout << "bp2.use_count() = " << bp2.use_count() << '\n';
}// UB: double-delete of Bad

struct Good: std::enable_shared_from_this<Good> // note: public inheritance
{
    std::shared_ptr<Good> getptr() {
        return shared_from_this();
    }
};
{
    // Good: the two shared_ptr's share the same object
    std::shared_ptr<Good> gp1 = std::make_shared<Good>();
    std::shared_ptr<Good> gp2 = gp1->getptr();
    std::cout << "gp2.use_count() = " << gp2.use_count() << '\n';
}

class scoped_thread{
    std::thread t_;
public:
    explicit scoped_thread(std::thread t)t_(std::move(t)){
        if (!t_.joinable())
            throw std::logic_error("No thread");
    }
    ~scoped_thread(){
        t.join();
    }
    scoped_thread(scoped_thread const&) = delete;
    scoped_thread& operator=(scoped_thread const&) = delete;
};

std::for_each(threads,begin(), threads.end(), std::mem_fn(&std::thread::join));

template <typename Derived>
struct cloneable{
  Derived* clone() const{
  return new Derived(static_cast<Derived const&>(*this));
  }
};
struct bar : clonealbe<bar>{...};

template <class T>
class enable_shared_from_this{
mutable weak_ptr<T> weak_this_;
public:
    shared_ptr<T> shared_from_this(){
        shared_ptr<T> p(weak_this_);
        return p;
    }
    ...
};

template<class Derived>
struct enable_profit{
    float profit(){
        Derived const & d = static_cast<Derived const &>(*this);
        return 42*(d.output)/d.input;
    }
};
struct department : enable_profit<department>}{
    int output;
    int input;
};