容器，顾名思义就是可以包含其他的对象。之前，接触过的类似容器的就是数组了。现在，接触一下容器，容器应该有很对好处。其中，很重要的一点就是容器有对应的迭代器，可以很容易的遍历。

     在C++里用到的最多的应该就是Vector了。

vector<int> a;
	if(a.empty()){
	for(int i=0;i<9;++i){
		a.push_back(i);
	}
	}
	cout<<a[3]<<endl;

     最好还是与迭代器一起用，这样的功能也是比较强的。

vector<int>::iterator iter;
	for(iter=a.begin();iter!=a.end();++iter){
		cout<<*iter<<endl;
	}

     使用迭代器可以很方便的遍历容器。特别是注意：迭代器的有效性，在操作时注意那些使迭代器失效的方法。我测试了一下：insert和erase方法竟然没有失效，也许是简单的原因吧！

iter=a.begin()+2;
	a.erase(iter);
	for(;iter!=a.end();++iter){
		cout<<*iter<<endl;
	}

删除后，迭代器并没有失效呀！但是，安全期间还是给iterator重新赋值吧！详细：

http://hi.baidu.com/nxxch1989/blog/item/c0ffec220d5c285d9922ed7c.html

突然发现有一个很重要的地方，但是一直不太明白。那就是引用与指针的区别，对指针思考的比较多，但是引用确实想当然。我的最大特点就是：想当然，缺少思考。什么是引用呢？

int a=0;
      int & ra=a;

引用就是对象的另一个名字，不引入新对象。

（1）引用被创建的同时必须被初始化（指针则可以在任何时候被初始化）。
（2）不能有NULL引用，引用必须与合法的存储单元关联（指针则可以是NULL）。
（3）一旦引用被初始化，就不能改变引用的关系（指针则可以随时改变所指的对象）。

引用的使用场合：

1.参数传递，某些大型对象可以节省空间。

2.重载操作符时，应该使用引用。例如：[]。

当然，使用引用的地方，可以使用指针。不知道，大家怎么理解的。

c/c++的数组与指针问题还是没有搞得太清楚，再仔细的研究一下。

指针：指向对象，存放对象的地址。

数组：一块连续的内存空间，静态初始化时确定数组的大小。

动态内存分配：在程序空间的动态内存区（堆）进行的空间分配。

赋值表达式：

LEFT = RIGHT

在赋值表达式，左右都能出现的成为左值。如：LEFT；只能出现在右边的称为右值。

在C语言里，又将左值分为了可修改与不可修改的左值。例如：数组名，就是个不可修改的左值。

int  a[4]={1,2,3,4};
int  *pa=a;

这样，pa与a都可以来引用数组里面的元素了，但是a与pa还是有区别的：pa可以作为可修改的左值，用来指向其他的对象，但是a是一个不可修改的左值，不能指向其他的对象。

数组名和指针的区别就是：数组名作为一个符号，在编译时是可知的，可以直接取到a的值。而指针作为变量，必须首先取得指针的值，然后得到地址。

通常，定义指针：

int *p = 0; // 或int *p = NULL;
int *p = new int;//C中用：int *p = (int *)malloc(sizeof(int)); 

二维数组的问题：

在c/c++里没有所谓的真正的二维数组，只有数组的数组，就是数组的元素还是数组，也是连续分配的空间。

例如：

int a[4][4];
int main(){
	int i=0;
	cout<<a[i]<<endl;
	cout<<&(a[i])<<endl;
	cout<<a+i<<endl;
	cout<<*(a+i)<<endl;
	cout<<*(a[i])<<endl;
	char c;
	cin>>c;
}

运行的结果为：

00A88138
00A88138
00A88138
00A88138
0

分别的意思是：

a[i]:第i行第0列地址。

&a[i]:第i行行首的地址。

a+i:第i行行首的地址。

*(a+i):第i行第0列地址。// *(a+i)+j与a+i+j 就有了明显的区别。

可以看出通过*（a+i）的行地址转为列地址，这样可以继续访问列里的元素。为什么：*（a[i]）的值为：0，不明白？？

怎么申请动态的二维数组：

c语言：

int **pp=0, i;
pp = (int **)malloc(sizeof(int*)*row);
for (i=0; i<row; i++)
pp[i] = (int *)malloc(sizeof(int)*colum); 

c++语言：

int **pp=new int* [row];
for(int i=0;i<row;++i){
	pp[i]=new int[colum];
}

当然，指针的理解还得靠以后的逐渐积累，例如在函数参数的传值的应用，函数指针，太强大，真是有点晕。参考了很多人的东西，表示感谢。

  学习C++表达式时首先就是表达式，常见到的算术，关系，逻辑，赋值，条件，逗号等与C的一致，而且比较熟悉。主要是了解一下位操作，自增、自减，箭头，sizeof等。

 1。位操作：~（求反），<<（左移），>>（右移），&（位与），^(为异或)，|（位或）。可以对整型值进行运算，但是最好是对无符号整型的运算。其实，位运算的语法并不难，难得是二进制运算，必须按位运算，对各种类型必须十分熟悉。其实，用c++自带的bitset 类更简单，容易。

.2。自增（自减）运算：记住两点：

》后置操作符返回未加1时的值。

》前置操作符返回加1后的值，即对象本身。

vector<int> a(4,1);
	vector<int>::iterator iter=a.begin();
	while(iter!=a.end())
		cout<<*iter++<<endl

注意：*iter++:等价于：*(iter++)，由于为后置++，所以解引用的是未加1之前的值。

.3。箭头(->):为指针类型的变量来取得属性。

 4。sizeof : 返回一个类型或对象的长度，返回类型为：size_t。特别的：

》&类型是为返回对象的长度。

》*类型返回指针类型的长度。

》数组返回数组长度乘以数组类型的长度。

复合表达式的问题：

优先级，结合性真的不好记，真的需要的时候就查表吧！（ps:最近学编译，才知道什么叫烦。。必须仔细搞懂）。此外，注意求值顺序的问题。这是个很有趣的问题，

int a[2]={1,2};
	int i=0;
	if(a[i++]<a[i])
		cout<<"a[0]<a[1]"<<endl;

如果左边先计算，a[0]<a[1]，则会输出；如果右边先计算，a[0]<a[0]，则不会输出。在我的机子里，不会输出。

new和delete的问题：

int *i=new int(6);
	cout<<*i<<endl;//1
	delete i;
	i=0;
	cout<<*i<<endl;//2

delete以后，例如delete i 后，i变成了悬浮指针，此时可使用此指针。最好立即将此指针赋值为0。然后，使用此指针会有异常出现。上面的例子中：第二次cout会出现异常。不同的编译器处理也不同，在vc中，上面的例子无法运行；在gcc中可以运行。在动态内存管理中，经常造成内存管理错误，比如删除指针错误，读取删除的对象。

类型转换：

隐式类型转换可能要理解一下，经常用，但是以前不太明白。

string s;
	while(cin>>s)

不知道测试的什么，在这里会做类型转换。

      现在才觉得当自学的时候，应该看一本好书。先到网上搜一下，再下决定。记得当时学C的时候，看的那本书并没有把C的特点给说明白，对指针也是很含糊。现在看着本书，真的很好。

     1.数组初始化。

如果没有显式的初始化：

》在函数体外定义的内置数组，会进行初始化：0。

》在函数体内定义的内置数组，不进行初始化。

》类类型，不论定义在何处，都自动调用默认构造函数。若没有默认的构造函数，则必须显式的初始化。

     2.数组不能直接赋值，而且一定要保证下标的范围。说起来简单，我就经常犯错误。

     3.const与*。

我以为理解的可以了，一个例子又把我搞晕了。

string s1="hello";
    string s2="world";
    typedef string * pstr;
    const pstr str=&s1;
    *str="world";
    cout<<*str<<endl;    

正常编译，不会出错。原来理解成了：const string * str。关键把typedef的作用理解错了，认为成文本替换了。正确的是：

string * const str。

ps:  The typedef keyword allows you to create a new alias for an existing data type. 

      4.减少c风格string的使用。主要是：减少错误。

其实，以前是自学过C++的，但是，感觉很挫。于是，又看《c++ primer》。觉得，这本书解释的很清楚，而且，很多提醒的地方，很好。就记录 一下。

(1)声明和定义。

变量的定义为变量分配存储的空间，还可以初始化。在一个程序中，变量只能定义一次。

变量的声明用于向程序说明变量的类型和名字。定义也是声明。可以 用extern来声明而不定义。

(2)const限定符。

容易混淆的原因是：c中的const与c++的const完全不同，在c中的const只是readonly的意思，并不是真正的常量定义符号，只是不能被赋值，但是，不能保证不被修改。而在C++中，const就是定义常量，而且是定义在该文件上的局部变量。

const 修饰指针符号*，位置不同时意义不同，这都是由于c语言声明的复杂性。 《c专家编程》有总结。

(3)头文件。

在头文件中，不应该含有变量或是函数的定义，但是可以定义类，const对象，inline函数。

(4)string.

标准库定义的string类型字符串，与字符串字面量不是同一类型。例如：两个字符串字面量不能用+来连接，但是string类型变量就可以。