C++概念点，持续更新

一，深拷贝，浅拷贝
深拷贝和浅拷贝可以简单理解为：如果一个类拥有资源，当这个类的对象发生复制过程的时候，资源重新分配，这个过程就是深拷贝，反之，没有重新分配资源，就是浅拷贝。下面举个深拷贝的例子。

深拷贝和浅拷贝的定义可以简单理解成：如果一个类拥有资源(堆，或者是其它系统资源)，当这个类的对象发生复制过程的时候，这个过程就可以叫做深拷贝，反之对象存在资源，但复制过程并未复制资源的情况视为浅拷贝。

浅拷贝资源后在释放资源的时候会产生资源归属不清的情况导致程序运行出错。

        Test(Test &c_t)是自定义的拷贝构造函数，拷贝构造函数的名称必须与类名称一致，函数的形式参数是本类型的一个引用变量,且必须是引用。

#include <iostream>
using namespace std;
class CA
{
　public:
　　CA(int b,char* cstr)
　　{
　　　a=b;
　　　str=new char[b];
　　　strcpy(str,cstr);
　　}
　　CA(const CA& C)
　　{
　　　a=C.a;
　　　str=new char[a]; //深拷贝
　　　if(str!=0)
　　　　strcpy(str,C.str);
　　}
　　void Show()
　　{
　　　cout<<str<<endl;
　　}
　　~CA()
　　{
　　　delete str;
　　}
　private:
　　int a;
　　char *str;
};

int main()
{
　CA A(10,"Hello!");
　CA B=A;
　B.Show();
　return 0;
}

二、运算符重载

#include <iostream>
using namespace std;
class Complex
{
public:
   Complex( ){real=0;imag=0;}
   Complex(double r,double i){real=r;imag=i;}
   Complex operator+(Complex &c2);//声明重载运算符的函数
   void display( );
private:
   double real;
   double imag;
};
Complex Complex::operator+(Complex &c2) //定义重载运算符的函数
{
   Complex c;
   c.real=real+c2.real;
   c.imag=imag+c2.imag;
   return c;
}
void Complex::display( )
{
   cout<<"("<<real<<","<<imag<<"i)"<<endl;
}
int main( )
{
   Complex c1(3,4),c2(5,-10),c3;
   c3=c1+c2; //运算符+用于复数运算
   cout<<"c1=";c1.display( );
   cout<<"c2=";c2.display( );
   cout<<"c1+c2=";c3.display( );
   return 0;
}

三、STL 容器

array：数组,初始化时定长度，不可以resize。
forward-list： 单向链表
list：双向链表。
queue：FIFO 队列
deque：double end queue，两头都可以加
stack：LIFO， top（）
set:
vector：
map：

 

1、我们不能对内置数组进行拷贝，但是可以对array进行拷贝：

  eg，inta[10]={1,2,3,4,,5,6};

      int copy[10]=a     //wrong

       

      array arr={1,2,3,4,5,6};

      array arr1=arr //right

2，顺序容器操作：

  1）除了array和forward_list外，每个容器都支持push_back将一个元素追加到数组的尾部。

  2）除了push_back， list、forward_list、deque容器还支持push_front操作，将元素插入到容器的头部。

  3）支持insert操作的容器有，vector、deque、list、和string

      eg，vector sevc；sevc.insert(sevc.begin(),1);警告：插入到vector末尾之外的任何位置都可能很慢

  4)访问元素有c.back();c.front();c[n],c.at(n)其中支持at操作的有string、vector、deque、array

   5)删除元素pop_front()和pop_back()用法和push_front和push_front相同；c.erase(p)删除迭代器p所指向的元素

     eg,list lst={12,3,4,5,6,5,7,8,9,};

        auto it=lst.begin();

        while(it!=lst.end())

　　　　　　　　　｛

　　　　　　　　　　　　if（*it%2）

　　　　　　　　　　　　｛

　　　　　　　　　　　　　　　it＝lst．Erase(it)；

　　　　　　　　　　　　　｝

　　　　　　　　　　　　else｛it＋＋；｝

　　　　　　　　　　｝

　　５）改变容器的大小，我们可以用resize来增大或缩小容器。array不支持resize

　　　　ｅｇ，list　llst(10,32)；

　　　　　　llst．Resize(15)；

　　６）vector对象是如何增长的

　　　　为了支持快速访问，vector将元素连续存储－－每个元素紧挨着前一个元素存储，考虑向vector和string中插入新元素时，如果没有足够的空间容纳新元素，容器不能简单的将它添加到内存中，因为元素必须是连续的，容器必须分配新的空间来保存已有元素和新元素，将已有的元素从旧位置移动到新空间，然后添加新元素，释放旧的空间。为了避免多次分配新空间，标准库实现者采用可以减少容器分配次数的策略，当不得不分配新空间时，vector和string通常会分配比新空间需求更大的内存空间以作备用。

　　７）容器中capacity和size的区别：

　　　　容器的size是指它保存的元素的数目；而capacity则是指不分配新内存空间的前提下它最多可以保存多少个元素,具体的值依赖于标准库的实现

四 extern 常见用法
extern用在变量声明中常常有这样一个作用，你在*.c文件中声明了一个全局的变量，这个全局的变量如果要被引用，就放在*.h中并用extern来声明。

五 指向类成员的指针
1.必须要是public的
2.指向成员指针的定义如下： int A:: *pc = &A::c;
指向f函数指针可以这样定义：它是一个普通的函数指针
 int (A:: *pfun)(int) = &A::fun;
http://blog.csdn.net/qhmao/article/details/4337701
点击(此处)折叠或打

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

class A {
 public:
  A(int a){
    a_ = a;
    cout<<"A is construction and a is "<<a_<<endl;
  }
  ~A(){
    cout<<"A is deconstruction"<<endl;
  }
  void Print(){
    cout<<"a is "<<a_<<endl;
  }

//  virtual void run()=0;

// private:
  int a_;
};



int main(void){
  A a(3);
  A b(8);
  int A::*p = &A::a_;
  void (A::*func)() = &A::Print;
  a.*p = 5;
  (a.*func)();
  b.*p = 7;
  (b.*func)();
  return 0;
}