0. c++ 萃取技术（根据参数获取对应的成员）  

    ```c
struct MyTest
{
    typedef int  value_type;
    value_type get(){return 1;}
};  
template<typename TYPE>
TYPE::value_type GetValue(TYPE t)
{
    reutrn t.get();
}
在没有使用萃取技术前，上面的方法对于下面的调用返回的是：
struct MyTest a;
GetValue(a);  // 返回1
int b=1;
GetValue(b); // 此时由于b是内建类型无法定义value_type 和get这两个属性
那么我们如何做呢？
------------------------------------------------------
template<typename T>
struct MyTest{
    typedef T value_type;
    value_type get() { return "test";}
};
//泛化模板（1）
template<typename T>
struct Traits {
    typedef typename T::value_type value_type;
    value_type get(T obj) { return obj.get();}
};
//模板完全特化（由于所有木板参数都特化了，如果只是部分参数特化则称为偏特化)（2）
template<>
struct Traits<int>
{
    typedef int  value_type;
    value_type  get(int obj){return 1;}
};
// 对int*特化（3）
template<>
struct Traits<int*>
{
    typedef int value_type;
    value_type  get(int *obj) { return 2;}
};
//此时GetValue方法可以改写成：
template<typename T>
typename Traits<T>::value_type GetValue(T t)
{
     Traits<T>().get(t);
}

int main()
{
    int a = 1;
    printf("%d\n",GetValue(a));//对应调用Traits(2)
    printf("%d\n",GetValue(&a));// 调用Traits(3)
    struct MyTest<char*> tt;
    printf("%s\n",GetValue<MyTest<char*> >(tt)); //调用traits(1)
}
输出：
1
1
test

    template<bool flag>
    class Traits<true>
    {
        public:
            void clone(T* pobj)
            {
                pobj->clone();
            }
    };
    template<bool flag>
        class Traits<false>
        {
            void clone(T*pobj)
            {
                printf(" non clonable");
            }
        };

[c++ 萃取](http://hsw625728.blog.163.com/blog/static/39570728200972105341629/)
0. 结构体成员偏移量
    
    ```c
   struct Test  
   {  
     int a;  
     int b;  
   };  
#define GET_MEMBER_OFFSET (_type,_mem) &(((struct _type*)0)->_mem)  
GET_MEMBER_OFFSET(Test,a) ---->0  
GET_MEMBER_OFFSET(Test,b) ---->4  

0. linux epoll  、网络编程注意事项
   0. `epoll_event` 中的data是一个`union`结构，所以使用时需要注意
   0.  对socket调用`recv` 采用`buff[2]`将会使得`recv`返回-1，且`errno=EAGAIN` 或者`EWOULDBLOCK` [non-block 模式]
   0.  对socket调用`recv`返回0表示客户端关闭了链接;如果返回值-1除了`EAGAIN \EWOULDBLOCK`其他的都认为链接有问题需要关闭
   0.  对socket调用`send`如果返回值-1除了`EAGAIN \EWOULDBLOCK`其他的都认为链接有问题需要关闭

0. 如何把字符串转换成int或者long

  ```c
  long atoi(char* str)
  {
    char c;
    long result=0;
    int mult =   1;
    if(str && *str == '-'){
         mult = -1;
         str++;
    }
    int desc;
    while((c=*str++) != '\0' )
    {
        int desc = c - '0';
    	if(desc >=0 && desc < 10)
        {
        	result *=10;
            result +=desc;
        }
       else
       {
       	 break;
    }
  return result * mult;
  }

  ```shell
 objdump -x -d -s a.out|c++filt |grep vtable
 
0000000000400c20  w    O .rodata        0000000000000018              vtable for T1
0000000000400be0  w    O .rodata        0000000000000018              vtable for T3
0000000000400c00  w    O .rodata        0000000000000018              vtable for T2
0000000000602080  w    O .bss   0000000000000058              vtable for __cxxabiv1::__class_type_info@@CXXABI_1.3
0000000000602200  w    O .bss   0000000000000058              vtable for __cxxabiv1::__si_class_type_info@@CXXABI_1.3  

sizeof TT=1--linux gcc，这是由c++标准规定的:c++标准规定一个空类以及那些不包含虚函数和非静态数据的成员时，其对象大小也是1. 其主要目的是为了类的实例化，如果大小为0完全不占用内存空间，那么空类无法获取实例的地址，this指针失效，因此不能被实例化。  
另外在类中的static成员不存储在对象成员中所以sizeof是不包含static类的成员.根据继承的权限来区分子类成员是否被继承如果非虚拟继承那么类对象大小与基类以至于，如果是虚拟继承那么需要考虑一个指向指针虚拟函数表的指针的大小，如果是多个虚拟继承也需要将该指针叠加其他情况需要考虑对齐，其对齐计算方法与结构体类似.  

0.  变参使用  

   ```c  
    void func(char* szFormat,...)
    {
         va_list args
         va_start(args, szFormat);
    
    
         vsprintf(buf,szFormat,args);
    
         va_end(args);
         //取参数
         va_args(args);    
    }

## 析构
```c  
#include <iostream>
#include <stdio.h>
#include <unistd.h>

using namespace std;
//只有基类的析构函数被声明定义为virtual，才会使得，一个基类的指针指向派生类的对象被释放时才会调用基类和派生类的
//析构方法，否则只有基类的析构方法被调用。
class base1{
public:
  base1(){
       cout<<"base1"<<endl;
  }
  ~base1(){
       cout<<"base1 destruct"<<endl;
  }
virtual void set(){
  cout<<__func__<<endl;
}
static int len;
};
int base1::len = 2;
class base2:public base1{
public:
  base2(){
       cout<<"base2"<<endl;
  }
  ~base2(){
       cout<<"base2 destruct"<<endl;
  }
virtual void set(){
  cout<<"derive "<<__func__<<endl;
}
};
///////////////////////////////////////////////////
class base1_v{
public:
  base1_v(){
       cout<<"base1_v"<<endl;
  }
  virtual ~base1_v(){
       cout<<"base1_v destruct"<<endl;
  }
};

class base2_v:public base1_v{
public:
  base2_v(){
       cout<<"base2_v"<<endl;
  }
  ~base2_v(){
       cout<<"base2_v destruct"<<endl;
  }
};
///////////////////////////////////////////////////
struct str1{
  int t;
  str1(){
       cout<<__func__<<endl;
  }
  virtual ~str1(){//只有为virtual才会使得delete的时候父类、子类析构函数被调用，
       cout<<"~"<<__func__<<endl;
  }
};
struct str2:public str1{
  str2(){
       cout<<__func__<<endl;
  }
  ~str2(){
       cout<<"~"<<__func__<<endl;
  }
  int tt2;
};




///////////////////////////////////////
class String{
public:
  String(){
       cout<<__func__<<endl;
  }
  // ~String(){
       //cout<<__func__<<endl;
    // }
  explicit String(char *buf){
       memcpy(m_buf,buf,m_len);
       cout<<"Constructor "<<__func__<<"(char *buf):set m_buf="<<m_buf<<endl;
  }
  explicit String(const String& obj){
       memcpy(m_buf,obj.m_buf,obj.m_len);
       cout<<__func__<<"Copy constructor"<<endl;
  }
  String& operator = (const String &obj){
       *this = obj;
       memcpy(this->m_buf,obj.m_buf,obj.m_len);
       cout<<__func__<<"Assigned"<<endl;
       return *this;
  }
  void print(){
       cout<<__func__<<":m_buf="<<m_buf<<endl;
  }
private:
  static int m_len;
  char *m_buf;
};
int String::m_len = 3;


///////////////////////////////////////
int main(int argc,char **argv){
// base2 b2;
// base1 b1=b2;
base1 *bb2 = new base2;
delete bb2;
cout<<"**********************"<<endl;
base1_v *bb2_v = new base2_v;
delete bb2_v;
cout<<"**********************"<<endl;

////////////////////////////////////
struct str1 *st = new str2;
delete st;
struct str1 sst;
cout<<"**********************"<<endl;
//////////////////////////////////


base1 *b = new base2;
base2 *b2 = dynamic_cast<base2*>(b);// base1 must have more than one virtual method include constructor
b->set();
b2->set();
delete b2;//两个指针释放其中一个即可

cout<<"**********************"<<endl;
// String s = "33";//compile error
String ss=String("33");//just call constructor one time.
String *ps=&ss;//will not call the constructor
String szStr("123");
String &pStr=szStr;//will not call the constructor,won't call the assignment constructor.
pStr.print();
return 0;
}
//** output **
// base1
// base2
// base1 destruct
// **********************
// base1_v
// base2_v
// base2_v destruct //有虚析构则会调用子类的析构函数
// base1_v destruct
// **********************
// str1
// str2
// ~str2
// ~str1
// **********************
// str1
// ~str1

```c  
struct demo {
int a;
char b[256];
char *follow;
};
struct demo *demo = (struct demo *) malloc (sizeof(strcut demo) + LEN);
```

```c
#include stdio.h
#include string.h
int func(char ar[2])
{ 
    printf(sizeof=%d\n,sizeof ar); 
    printf(strlen = %d,strlen(ar));
}
int main(){
    char *p = hello;func(p);
    return 0;
}


Output:

sizeof=4
strlen = 5
````

0. 指针例子  
C,pasted just now:

 ```c
 #include stdio.h
 #include string.h
 int func(long L)
 {
     L=L+1;
 }
 int func2(long *pL)
 {
     pL +=1;
 }
 int func3(long *pL){
     *pL +=1;
 }
 int main(){
     long lValue =20;
     long *plValue = lValue;
     func(lValue);
     printf(lvalue = %d,*plValue=%d\n,lValue,*plValue);
     func(*plValue);
     printf(lvalue = %d,*plValue=%d\n,lValue,*plValue);
     func2(lValue);
     printf(lvalue = %d,*plValue=%d\n,lValue,*plValue);
     func2(plValue);
     printf(lvalue = %d,*plValue=%d\n,lValue,*plValue);
     func3(lValue);
     printf(lvalue = %d,*plValue=%d\n,lValue,*plValue);
     
     func3(plValue);
     printf(lvalue = %d,*plValue=%d\n,lValue,*plValue);
     return 0;
 }


Output:

lvalue = 20,*plValue=20lvalue = 20,*plValue=20lvalue = 20,*plValue=20

lvalue = 20,*plValue=20lvalue = 21,*plValue=21lvalue = 22,*plValue=22
 ```
0. string 查找
C++中使用的string 中有一个属性npos即string::npos可以用来判断string中查找的字符串是否存在  

 ```c
public static member constant
<string>
std::string::npos

static const size_t npos = -1;
 ```
Maximum value for size_t
npos is a static member constant value with the greatest possible value for an element of type size_t.  
This value, when used as the value for a len (or sublen) parameter in string's member functions, means "until the end of the string".  
As a return value, it is usually used to indicate no matches.    
This constant is defined with a value of -1, which because size_t is an unsigned integral type, it is the largest possible representable value for this type.   
 ```c
string str;

pos=str.find_first_of("h");

if(pos!=string::npos)//  match
 ```
0. linux下整型转换字符  
在windows下可以通过，itoa(value,buffer,type),value是待转换的值，buffer，存放转换后的字符串，最后我一个参数是表示需要转换的进制的形式，另外，她的头文件是stdlib.h,但是很奇怪在Linux下gcc并不支持他，另外在windows下还可以通过CString::format来进行转换，该方法在linux下依然是行不同的，在Linux下可以通过sprintf(buffer,"format",param) 5此方法在window下依然是行的通的，或者通过宏来实现   
 ```c
#define Tostring（a） #a
 ```
那么展开后就是const char*即"xxx"  

0. c/c++ 数组做形参：
```c
int test(float a[10]);