int a[10];
int *a = new int[10];
前者系统会在栈中分配空间，系统会自动实现内存的分配和回收。
后者系统会在堆中分配空间，系统一般不会自动实现内存的回收，如果程序中没有delete，可能会造成内存的泄露。
后者比前者灵活，它是动态分配内存的，会根据程序的需要分配，需要多少自己就决定分配多少，浪费空间少。

STL的vectorstring的初始化方式总结

（1）第一种，类似于数组的方式：

std::vector<std::string> strArray(10);
strArray[0] = "hello";
strArray[1] = "world";
strArray[2] = "this";
strArray[3] = "find";
strArray[4] = "gank";
strArray[5] = "pink";
strArray[6 ]= "that";
strArray[7] = "when";
strArray[8] = "how";   
strArray[9] = "cpp";

（2）push_back的方式：

vector<string> strArray;
strArray.push_back("hello");
strArray.push_back("world");
strArray.push_back("this");
strArray.push_back("find");
strArray.push_back("gank");
strArray.push_back("pink");
strArray.push_back("that");
strArray.push_back("when");
strArray.push_back("how");   
strArray.push_back("cpp");

（3）构造函数的方式：

string str[]={"hello","world","this","find","gank","pink","that","when","how","cpp"};
vector<string> strArray(str, str+10);

C++ string删除字符串中所有的指定字符

erase函数的原型如下：

（1）string& erase ( size_t pos = 0, size_t n = npos );
（2）iterator erase ( iterator position );
（3）iterator erase ( iterator first, iterator last );

也就是说有三种用法：
（1）erase(pos,n); 删除从pos开始的n个字符，比如erase(0,1)就是删除第一个字符
（2）erase(position);删除position处的一个字符(position是个string类型的迭代器)
（3）erase(first,last);删除从first到last之间的字符（first和last都是迭代器）
注意第2，3种，参数均是迭代器，不是int类型的。

---

C++中要从string中删除所有某个特定字符, 可用如下代码

str.erase(std::remove(str.begin(), str.end(), 'a'), str.end());

其中, remove来自<algorithm>, 它的签名是

1. template <class ForwardIterator, class T>
2. ForwardIterator remove (ForwardIterator first, ForwardIterator last, const T& val);

作用: 在容器中, 删除[first, last)之间的所有值等于val的值.
删除方法: 将某个等于val的值用下一个不等于val的值覆盖.
返回值: 一个迭代器 (记作newEnd), 该迭代器指向最后一个未被删除元素的下一个元素, 即相当于容器新的end.
所以, 运行完remove后, 容器的[first, newEnd)内的元素即为所有未被删除的元素, [newEnd, end)之间的元素已经没用了.
这样, 再运行str.erase(newEnd, str.end())即可清空[newEnd, end)之间的元素.
std::remove_if与remove类似, 只是它接受的第三个参数是个函数.

3. // remove_if example
4. #include <iostream>     // std::cout
5. #include <algorithm>    // std::remove_if
6. bool IsOdd (int i) { return ((i%2)==1); }
7. int main () {
8. int myints[] = {1,2,3,4,5,6,7,8,9};            // 1 2 3 4 5 6 7 8 9
9. // bounds of range:
10. int* pbegin = myints;                          // ^
11. int* pend = myints+sizeof(myints)/sizeof(int); // ^                 ^
12. pend = std::remove_if (pbegin, pend, IsOdd);   // 2 4 6 8 ? ? ? ? ?
13. // ^       ^
14. std::cout << "the range contains:";
15. for (int* p=pbegin; p!=pend; ++p)
16. std::cout << ' ' << *p;
17. std::cout << '\n';
18. return 0;
19. }
Output:
myvector contains: 10 30 30 10 10 0 0 0
还有个std::remove_copy, 签名:

20. template <class InputIterator, class OutputIterator, class T>
21. OutputIterator remove_copy (InputIterator first, InputIterator last,
22. OutputIterator result, const T& val);
它会把[first, last)之间不等于val的元素都向从result开始的容器拷贝.

23. // remove_copy example
24. #include <iostream>     // std::cout
25. #include <algorithm>    // std::remove_copy
26. #include <vector>       // std::vector
27. int main () {
28. int myints[] = {10,20,30,30,20,10,10,20};               // 10 20 30 30 20 10 10 20
29. std::vector<int> myvector (8);
30. std::remove_copy (myints,myints+8,myvector.begin(),20); // 10 30 30 10 10 0 0 0
31. std::cout << "myvector contains:";
32. for (std::vector<int>::iterator it=myvector.begin(); it!=myvector.end(); ++it)
33. std::cout << ' ' << *it;
34. std::cout << '\n';
35. return 0;
36. }

Output:
myvector contains: 10 30 30 10 10 0 0 0