C++

#define STATIC_ASSERT(_cond,_name)      typedef char STATIC_ASSERT_FAILED_ ## _name [ (_cond) ? 1 : -1 ]
#define STATIC_SIZE_ASSERT(_type,_size) STATIC_ASSERT ( sizeof(_type)==_size, _type ## _MUST_BE_ ## _size ## _BYTES )

int main() {
  STATIC_SIZE_ASSERT(int,8);
  return 0;
}

#include <iostream>
class A{
 public:
  A(){
    std::cout << "A()" << std::endl;
  }
};
void foo(){
  static A a;
}
int main(){
  foo();
  return 0;
}

.globl _Z3foov
    .type	_Z3foov, @function
_Z3foov:
.LFB1445:
    pushq	%rbp
.LCFI3:
    movq	%rsp, %rbp
.LCFI4:
    subq	$32, %rsp
.LCFI5:
    cmpb	$0, _ZGVZ3foovE1a(%rip)
    jne	.L10
    movl	$_ZGVZ3foovE1a, %edi
    call	__cxa_guard_acquire
    testl	%eax, %eax
    je	.L10
    movb	$0, -1(%rbp)
    movl	$_ZZ3foovE1a, %edi
.LEHB0:
    call	_ZN1AC1Ev
.LEHE0:
    movl	$_ZGVZ3foovE1a, %edi
    call	__cxa_guard_release
    jmp	.L10
.L19:
    movq	%rax, -24(%rbp)
.L13:
    movq	-24(%rbp), %rax
    movq	%rax, -16(%rbp)
    cmpb	$0, -1(%rbp)
    je	.L15
    jmp	.L16
.L15:
    movl	$_ZGVZ3foovE1a, %edi
    call	__cxa_guard_abort
.L16:
    movq	-16(%rbp), %rax
    movq	%rax, -24(%rbp)
.L17:
    movq	-24(%rbp), %rdi
.LEHB1:
    call	_Unwind_Resume
.LEHE1:
.L10:
    leave
    ret

// this是这个callee函数地址
// callsite是caller函数调用点地址(不是函数地址)
void __cyg_profile_func_enter(void *this, void *callsite);
void __cyg_profile_func_exit(void *this, void *callsite);

#include <cstdio>
#include <cstdlib>
void foo() __attribute__((no_instrument_function));
void foo() {
    printf("%s\n",__func__);
}
int main() {
    printf("main\n");
    return 0;
}
extern "C" {
    void __cyg_profile_func_enter(void* callee, void* callsite)  __attribute__((no_instrument_function));
    void __cyg_profile_func_exit(void* callee, void* callsite) __attribute__((no_instrument_function));
    void __cyg_profile_func_enter(void* callee, void* callsite) {
        foo();
    }
    void __cyg_profile_func_exit(void* callee, void* callsite){
        foo();
    }
}

#include <unistd.h>
#include <dlfcn.h>
#include <cstring>
#include <cstdlib>

void* malloc(size_t size){
    write(2,"do malloc\n",strlen("do malloc\n")+1); // 这里不能够用printf,因为内部可能会调用malloc
    static void* (*pmalloc)(size_t size)=0;
    if(!pmalloc){
        pmalloc=(void*(*)(size_t size))(dlsym(RTLD_NEXT,"malloc"));
    }
    return pmalloc(size);
}

void free(void *p){
    write(2,"do free\n",strlen("do free\n")+1);
    static void (*pfree)(void* p)=0;
    if(!pfree){
        pfree=(void(*)(void* p))(dlsym(RTLD_NEXT,"free"));
    }
    return pfree(p);
}

#include <vector>
using namespace std;
class Foo {
 public:
  static const int MEMBER = 1;
};

int main(){
  vector<int> v;
  v.push_back( Foo::MEMBER );       // undefined reference to `Foo::MEMBER'
  v.push_back( (int) Foo::MEMBER ); // OK
  return 0;
}

#include <string>
int main() {
  std::string s1="h";
  std::string s2="o";
  const char* s=(s1+s2).c_str();
  return 0;
}

/* coding:utf-8
 * Copyright (C) dirlt
 */

#include <sys/time.h>
#include <map>
#include <string>
#include <cstdio>

using namespace std;

static inline double gettime_ms() {
  struct timeval tv;
  gettimeofday(&tv, NULL);
  return tv.tv_sec * 1000.0 + tv.tv_usec * 0.001;
}

static const int NUMBER = 10000000;
static const char* PREFIX = "s";

static void action() {
  double start = gettime_ms();
  map<string, long> dict;
  char buf[64];
  char buf2[64];
  for(int i = 0; i < NUMBER; i++) {
    snprintf(buf, sizeof(buf), "%s%d", PREFIX, i);
    dict[buf] = i;
  }
  for(int i = 0; i < NUMBER; i++) {
    snprintf(buf, sizeof(buf), "%s%d", PREFIX, i);
    snprintf(buf2, sizeof(buf2), "%s%d", PREFIX, (i + 1000) % NUMBER);
    dict[buf] += dict[buf2];
  }
  double end = gettime_ms();
  printf("%.2lf\n", end - start);
}

static void action2() {
  double start = gettime_ms();
  map<int, long> dict;
  for(int i = 0; i < NUMBER; i++) {
    dict[i] = i;
  }
  for(int i = 0; i < NUMBER; i++) {
    dict[i] += dict[(i + 1000) % NUMBER];
  }
  double end = gettime_ms();
  printf("%.2lf\n", end - start);
}

int main() {
  action();
  action2();
  return 0;
}

class A{
 public:
  void fun(Executor* x,std::string s){
    std::cout << "executor=" << x << ", s=" << s << std::endl;
  }
}; // class A

class B{
 public:
  void fun(Executor* x,int s){
    std::cout << "executor=" << x << ", s=" << s << std::endl;
  }
}; // class B

x.push(boost::bind(&A::fun,&a,_1,"hello"));
x.push(boost::bind(&A::fun,&a,_1,"world"));
x.push(boost::bind(&B::fun,&b,_1,123));
x.push(boost::bind(&B::fun,&b,_1,456));

template<typename T1, typename T2>
auto bar(const T1 a, const T2 b) -> decltype(a + b) {
    return a + b;
}

class A {
  public:
    class B {};
    B foo();
};

// A::B A::foo() { return B(); }
auto A::foo() -> B { return B(); }

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

std::function<int()> foo() {
    int count = 0;
    auto f = [&count]() {
        count += 1;
        return count;
    };
    return f;
}

int main() {
    auto f = foo();
    auto x = f();
    // cout << x << endl;
}

#include <functional>
#include <iostream>
using namespace std;
using std::placeholders::_1;
using std::placeholders::_2;
using std::placeholders::_3;
int foo(int a, int b, int c) {
    return a + b + c;
}
int main() {
    auto f1 = bind(foo, 1, 2, _1);
    auto f2 = bind(foo, _1, _2, 3);
    cout << f1(10) << ", " << f2(2,4) << endl;
    return 0;
}

#include <cstdio>
#include <iostream>

#if (__cplusplus > 199711L)
#define cxx0x
#endif

#include <memory>
using namespace std;


class A {
  public:
    int v;
    string s;
    A(int v, string s){
        this -> v = v;
        this -> s = s;
        // cout << "ctor" << endl;
    }
    A(const A& x) {
        this->v = x.v;
        this->s = x.s;
        cout << "copy ctor:";
        cout << &x << " -> " << this << endl;
    }
    A& operator=(const A& x) {
        this->v = x.v;
        this->s = std::move(x.s);
        cout << "copy operator=:";
        cout << &x << " -> " << this << endl;
        return *this;
    }
#ifdef cxx0x
    A(A&& x) {
        this->v = x.v;
        this->s = std::move(x.s);
        cout << "move ctor:";
        cout << &x << " -> " << this << endl;
    }
    A& operator=(A&& x) {
        this->v = x.v;
        this->s = std::move(x.s);
        cout << "move operator=:";
        cout << &x << " -> " << this << endl;
        return *this;
    }
#endif
};

// 这里增加条件语句，可以使得编译器不会直接在返回地址上开辟对象A
// 从而达到实验目的，否则只会调用一次ctor（内部的）而不会调用copy ctor/move ctor.
static int x = 0;
A bar() {
    A a(10, "hello, world");
    A b(20, "hello, worldb");
    if (x == 0) {
        cout << "inside bar: " << &a << endl;
        return a;
    } else {
        cout << "inside bar: " << &b << endl;
        return b;
    }
}

#ifdef cxx0x
int foo1() {
    cout << "----- foo1(test c++0x) -----" << endl;
    A pa(bar()); // move ctor
    cout << "pa = " << &pa << "/" << &(pa.v) << endl;

    cout << "-----" << endl;
    A pa2(10, "s");
    pa2 = bar(); // move ctor and move operator=
    cout << "pa = " << &pa2 << "/" << &(pa2.v) << endl;


    cout << "-----" << endl;
    if (std::is_same<decltype(pa), A&&>::value) {
        cout << "same type" << endl;
    }
    A pb = pa; // copy ctor.
    cout << "pb = " << &pb << endl;

    cout << "-----" << endl;
    A pc = std::move(pb); // move ctor.
    cout << "pc = " << &pc << endl;
    return 0;
}
#endif

int foo2() {
    cout << "----- foo2(test c++03&0x) ----" << endl;
    // move ctor at c++0x
    // copy ctor at c++03
    A pa = bar();
    cout << "pa = " << &pa << "/" << &(pa.v) << endl;

    // move ctor / move operator= in c++0x.
    // copy ctor / copy operator= in c++03.
    cout << "-----" << endl;
    A pa2(10, "s");
    pa2 = bar();
    cout << "pa = " << &pa << "/" << &(pa.v) << endl;

    cout << "-----" << endl;
    A pb = pa; // copy ctor.
    cout << "pb = " << &pb << endl;
    return 0;
}

int main() {
#ifdef cxx0x
    foo1();
    cout << endl << endl;
#endif
    foo2();
}