C++ 模板类vector＜int＞ vi,以及模板迭代器vector＜int＞::iterator p = vi.begin()；

// ConsoleApplicationC++jichu9.cpp : Defines the entry point for the console application.
//

#include "stdafx.h"
#include "iostream"
#include "string"

#include "vector"
using namespace std;
/*
字符串
C中  char str[] {"Im ok!"};
c++  string
*/
//-- 字符数组的常用操作
void charArrayOper(){
	char str[] {"Iam Ok!"};
	printf("%s\n", str);
	printf("%d\n", sizeof(str)); //8 占多少内存
	printf("%d\n", strlen(str)); //7 字符数组的有效长度

	char str2[100] = {"abc"};
	printf("%d\n", sizeof(str2)); //100
	printf("%d\n", strlen(str2)); //3

	char * p = "test";//存放在只读常量区，不能通过p指针对只读常量区内存进行操作； const char * p = "test"; 正常应该这么写
	char * q = "test";
	cout << "&p=" << p << endl;
	cout << "&q=" << q << endl;
	printf("&p = %p\n", p);
	printf("&q = %p\n", q);

}
//-- string 对象的常用操作
void stringObjOperat(){
	string s(5, 'n');
	cout << s.c_str() << endl;
	s.empty();
	s.size();
	s.length();
	s[s.length()-1];

	string s1;
	string s2 = s + s1;
	s1 == s2 ? true : false;
	cout << s1 << endl;
	for (auto &c : s){
		c = toupper(c);
	}
}

//-- 模板类vector<int> v;
void testVector(){
	/*
	vector 可以理解为一个残缺的类类型
	vector<类型> 才是一个完整的类类型
	*/

	struct MyStruct
	{
		int num;
		char sex;
	};
	vector<MyStruct> v;
	vector<int> vi;
	vi.push_back(2);

	vector<int> vi1 = vi;
	vector<int> vi2(vi);
	vector<string> vstr = { "avn", "def", "sss" };
	vector<int>(5, -22); //-- 5个元素，每个元素都是-22
	vector<string>(100); 

	vi.empty();
	vi.push_back(5);
	vi.size();
	vi[vi.size() - 1];
	vi.clear();
	vi != vi1 ? true : false;
	for (auto &item : v)
	{
		item.num *= 2;
		//-- 在循环内不要增删元素，改变vector的容量
	}
}

class testVector{
public:
	static int * testIterator;
};
//-- 迭代器
void testIterator(){
	//-- vector<int>::iterator; 相当于 testVector::testIterator;
	vector<int>::iterator;
	testVector::testIterator;
	//-- 每一种容器，如vector 都定义了一个叫begin的成员函数 和一个叫end的成员函数
	vector<int> vi = { 100, 200, 300 };
	for (vector<int>::iterator iter = vi.begin(); iter != vi.end(); iter++)
	{
		cout << *iter << endl;
	}
	//vi.begin()  指向第一个元素
	//vi.end() 指向容器的最后一个元素的末端。（他不指向最后一个元素）
	//-- 如果容器为空，则begin和end返回的迭代器相同


	//-- 反向迭代器
	for (vector<int>::reverse_iterator ra = vi.rbegin(); ra != vi.rend(); ra++)
	{
		cout << *ra << endl;
	}
	//vi.rbegin()  指向最后一个元素
	//vi.end() 指向容器的第一个元素的前端。（他不指向第一个元素）

	//-- 迭代器运算符 :  一定要确保迭代器指向有效的容器中的元素
	// ra++ 
	// ra-- 
	// iter == ra
	// iter != ra
}

void testConst_iterator(){
	vector<int> vi{ -10, -20, -30 };
	int cnt = 0;
	//vector<int>::const_iterator c_iter  相当于常量指针（const char * p）指针指向的内容不变（不能通过指针 改变指针指向的内容），  指针本身可变（可以改变指针的指向）
	for (vector<int>::const_iterator c_iter = vi.begin(); c_iter != vi.end(); c_iter++)
	{
		cout << *c_iter << endl;
		//*c_iter = 8;  NG
		//-- 使用了迭代器的循环中  插入元素到容器，那只插入一个元素后就应该立即跳出循环体
		cnt++;
		if (cnt == 1)
		{
			vi.push_back(888);
			break;
			//-- 跳出循环，因为一旦原有的内存不够用了， 系统会重新分配内存 将原有内存的数据复制到新内存，原有内存数据引用失效。
		}
	}
	for (vector<int>::const_iterator c_iter = vi.begin(); c_iter != vi.end(); c_iter++)
	{
		cout << *c_iter << endl;
	}
}
//-- 连续插入数据带vector
void insertToVector(){
	cout << "连续插入数据带vector" << endl;
	vector<int> vi = { 1, 2, 3 };
	int cnt = 5;
	auto p = vi.begin();
	while (p != vi.end())
	{
		p = vi.insert(p, 6);
		if (cnt >= 18)
		{
			break;
		}
		++cnt;
		p++;
	}

	//-- 打印输出数据
	auto pp = vi.begin();
	while (pp != vi.end())
	{
		cout << *pp << endl;
		++pp;
	}

	//-- 一个元素一个元素的删除
	auto ppp = vi.begin();
	while (!vi.empty())
	{
		//-- erase删除当前位置元素， 返回下一个元素位置迭代器。
		ppp = vi.erase(ppp);
	}
}
int _tmain(int argc, _TCHAR* argv[])
{
	char str [] { "ssss" };

	charArrayOper();
	testVector();
	testIterator();
	testConst_iterator();
	insertToVector();
	return 0;
}