数组

（1）传统的数组实现方式
见另一篇博客传统数组
（2）自动分配数组
（1）一维数组（malloc/delete）

#include <iostream>
        #include<iterator>
        #include<list>
        #include<stdlib.h>
        #include<stdio.h>
        #include<time.h>

        using namespace std;
        int main(void)
        {
                cout<<"使用malloc实现动态分配的数组空间"<<endl;
                int *p1 = (int *)malloc(sizeof(int)*10);
                for(int i=0; i<10; i++) {
                        *(p1+i) = i+10;
                }
                for(int i=0; i<10; i++) {
                        cout << *(p1+i);
                }
            cout << endl;
                free(p1);

                cout<<"\n使用new实现动态分配的数组空间"<<endl;
                int *p2 = new int[10];
                for(int i=0; i<10; i++) {
                        *(p1+i) = i+20;
                }
                for(int i=0; i<10; i++) {
                        cout << *(p1+i);
                }
            cout << endl;
                delete p2;

                return 0;
        }

（2）多维数组

#include <iostream>
        #include<iterator>
        #include<list>
        #include<stdlib.h>
        #include<stdio.h>
        #include<time.h>

        using namespace std;
        int main(void)
        {
                cout<<"使用malloc开辟e二维数组"<<endl;
                int **p1 = (int **)malloc(sizeof(int *)*5);
                for(int i=0; i<5; i++) {
                        *(p1+i) = (int *)malloc(sizeof(int)*5);
                }
                for(int i=0; i<5; i++) {
                        for(int j=0; j<5; j++) {
                                p1[i][j] = i+j;
                        }
                }
                for(int i=0; i<5; i++) {
                        for(int j=0; j<5; j++) {
                                cout<< *(*(p1+i)+j)<<" ";
                        }
                        cout<<endl;
                }
                for(int i=0; i<5; i++) {
                        free(*(p1+i));
                }
                free(p1);

                cout<<"\n使用new关键字动态开辟二位数组"<<endl;
                int **p2 = new int*[5];
                for(int i=0; i<5; i++) {
                        *(p2+i) = new int[5];
                }
                for(int i=0; i<5; i++) {
                        for(int j=0; j<5; j++) {
                                p2[i][j] = i+j;
                        }
                }
                for(int i=0; i<5; i++) {
                        for(int j=0; j<5; j++) {
                                cout<< *(*(p2+i)+j)<<" ";
                        }
                        cout<<endl;
                }
                for(int i=0; i<5; i++) {
                        delete(*(p2+i));
                }
                delete p2;

                return 0;
        }

（3）使用动态分配方式实现数组时需要注意
    （1）动态分配实现多维数组时，利用的是多级指针来实现的，而传统的
        多维数组是靠数组指针这种特殊形式的指针实现的，但是让它
        们在多维构建的逻辑上都是一样。

    （2）传统方式实现的多位数组本质还是一维数组，元素全部都是连续的
        但是动态分配空间不是的，它是由指针数组组织起来的，所有
        的一维数组的空间不一定是连续的。

    （3）动态方式实现多维数组时，由于单维数组间的空间并不连续，因此
        在释放内存空间时一定要小心，不要导致内存泄漏。需要分批
        释放空间，就像上面的例子所示。

    （4）传统的多位数组中*的作用与动态分配的多维数组访问时*的含义是不同
        的，比如如二维数组*访问形式：
        传统方式：*(*(buf+i)+j) = 5; buf[i][j]
            其中的*(buf+i)中的*实际上是强制转换的功能，强制的
            将数组指针类型转换为数组元素指针类型。


        动态分配方式：*(*(p+i)+j) = 5; buf[i][j]
            其中的*(p+i)中*其实时寻找空间操作，或者也称为解引用
            操作。

    （5）动态分配的数组不能初始化，只能使用赋值的方式给值。


    （6）传统方式实现的数组，特别是多维数组会大量涉及数组指针的概念
        动态的方式实现的数组则大量涉及多级指针的概念。

（4）什么时候使用自动内存分配的方式实现数组
    当需要程序运行后，动态确定数组的大小的时候，这个时候就是必须使用这种方式。
（3）C++提供数组类封装的方式式。
c++中还有一种数组类封装的实现方式，就对传统和动态分配这两种方式进行了类封装，类名为array，有些编译器不支持这样的实现方式。
使用

（1）一维
array<int,5> myarray={1,2,3,4,5};  

（2）二维 
array<array<int,2>,3 > myarray2D={1,2,3,4,5,6}; 
（4）c++中数组实现方式总结
（1）传统方式 
    自定义固定长度数组时，常用这种方式
（2）动态分配方式
    需要在程序运行时具体决定元素个数时使用这种方式，C++中的STL vector
    容器就是使用的动态分配数组的方式封装实现的。

（3）array类封装方式
    array对数组进行了类封装，至于它的具体实现方式要看定义类对象的
    方式。如果是通过new关键字实现的，就是使用动态分配的方式。
    否者就是使用传统的方式实现。

在java中，java摈弃了c++个各种各样复炸的数组实现方式，只保留了Array类封装
样式的数组，在java中由于类对象空间全部都是开辟于动态分配区（堆）,因此本质上
java的数组全部采用动态空间分配方式，单维数组空间之间不连续。


（3）字符串（特殊的字符数组）
（1）C样式字符串
    （1）数组形式
    （2）指针形式

（2）C++提供的string形式
    （1）声明   
        //string str1 = "hello world";
            //string str1("hello wolrd");
            string *str1 = new string("hello world");

        如果不初始化字符串就是空字符串。


    （2）string对[]/=/==/+进行了重载
        （1）可以使用[]访问字符串字符
        （2）可以使用=直接相互间赋值
        （3）可以使用==比较两个字符串对象是否相等，但是如果是指针形式的对象，不能使用==判断
                string *str1 = new string("hello world");
                string *str2 = new string("hello world");
                string str3("hello world");
                string str4("hello world");

                str1[0] = '$';

                string str;
                if(str3 == str4) {
                        str = "==";
                } else {
                        str = "!=";
                }   
                cout << str  << endl;

        （4）字符串可以使用+进行连接，但是要求第一个必须是string类型的字符串
            不能使用字符串字面量（常量字符串，任何形式的C类型的字符串），因为
            只有string重载了+运算符
                    string str1 = "hello!, ";
                    string str = str1+"world"+" is "+ "world";


            注意：
                    string *str1 = new string("hello!, ");
                    char *str2= " wwww ";
                    string str = *str1+"world"+ str2 + " is "+ "world";

                    cout << str << endl;  
        (5)+=的使用
            （1）左边的第一个必须是string类型字符串
            （2）右边的string类型变量必须先声明后使用
                        string *str1 = new string("hello!, ");
                        string str;
                        // = *str1 +  "world"+" is "+ "world";
                        str += *str1 + "world"+" is "+ "world";

                        cout << str << endl;    


        （6）使用>>向string操作数中输入字符串时，无法输入带有空格的字符串
            （1）使用getline(cin, str);函数，就可以输入带有空格的字符串，
                默认结尾符是回车。

            （2）使用第三参数输入指定结尾符的字符串
                getline(cin, str，'#');//输入#结尾的字符串

    （3）访问字符串的字符
        由于string对[]进行了重载，因此，可以使用[]访问字符串中的元素，既可以作为左值使用
        也可以作为右值使用。
                string str;

                getline(cin, str);

                for(int i=0; i<str.length(); i++) {
                        str[i] = std::toupper(str[i]);
                }

                cout<< str << endl;


    （4）常见操作字符串的一些string的成员函数的回顾
        （1）substr()：提取子字符串
            （1）只有一个参数时：指定索引位置
                如果指定的索引位置超出范围，会抛出超出范围的异常。

            （2）两个参数时：第一个参数指定索引位置，第二个参数指定提取的字符串长度
                （1）如果指定的索引位置超出范围，会抛出超出范围的异常。
                （2）如果指定的长度超过范围，自动提取到字符串结束为止即可。

        （2）字符串比较
            （1）c字符串的比较
                （1）比较的函数：使用strcmp或者strncmp函数进行比较
                    （1）strcmp函数：比较两个字符串是否完全相等
                        char *p = "hello";
                        char buf[] = {"hellw"};
                        int ret = strcmp(p, buf);
                    （2）strncmp函数：比较两个字符串前n个字符是否相等
                        char *p = "hello";
                        char buf[] = {"hellw"};
                        int ret = strncmp(p, buf, 4);

                    (3)函数返回值：如果两个字符串相等，返回0，如果第一个参数指向的字符串小于第二个参数指向的字符串，
                    返回一个小于0的数，否则就返回一个大于0的数。


                （2）字符串比较的规则（以strcmp为例）
                    将两个字符串的字符逐个今次那个比较，知道找到不同的字符或者到达字符串的末尾，如果找到不同字符，就
                    根据器asscii值进行比较（函数返回asscii差值），如果两个字符串找到最后发现长度不相等，就返回长度差值。


            （2）使用重载后的比较运算符 ==/!=/<=/>=进行比较
                （1）比较的方法与strcmp同
                （2）对string对象进行比较，或者将string对象与c样式的字符串进行比较
                            string str1 = "hello";
                            string str2 = "he";

                            string str;
                            if(str1 < "dsdf") {
                                    str = "small";
                            } else {
                                    str = "lage";
                            }

                            cout<< str << endl;


            （3）使用compare成员函数进行比较
                （1）比较的方法与strcmp同
                （2）对string对象进行比较，或者将string对象与c样式的字符串进行比较
                （3）compare不同的重载版本
                    (1)word.compare(string str);：比较word与str是否完全相等
                    (2)word.compare(int index, int num, string str1);：比较word中从index开始向后num个字符与str1是否完全相等。
                    (3)word.compare(int index1, int num1, string str1, int dex2, int num2);：比较word与str1的子字符串是否相等。

                （4）使用substr实现子字符串的比较
                    if(word.substr(2，4)==word.substr(3，5));


        （3）搜索字符串
            （1）搜索成员函数find：返回索引
            （2）的不同重载版本
                （1）word.find(char c)：在word中搜索字符，成功返回索引，失败返回string::npos（4294967295）表示非法字符位置。
                （2）word.find(string/char * str)：    
                （3）word.find(string/char * str, int i)：从word的i位置开始找。
                （2）word.find(string/char * str, int i， int n)：从word的i位置开始找str中前n个字符。

            （3）逆向搜索函数rfind，用法同find
            （4）在字符串中搜索字符集中的字符
                （1）涉及函数
                    （1）word.find_first_of(string/char str);：从word头开始索引，第一次出现str中字符的位置
                    （2）word.find_first_not_of(string/char str);：从word头开始索引，第一次出现非str中字符的位置
                    （3）word.find_last_of(string/char str);：从word尾部开始索引，第一次出现str中字符的位置
                    （4）word.find_last_not_of(string/char str);：从word尾部开始索引，第一次出现非str中字符的位置

                （2）使用例子：将字符串拆分成子字符串

#include <stdlib.h>
                        #include <iostream>
                        #include <string>

                        using namespace std;
                        int main(void)
                        {
                                string str = "sdfa sdaf,sdffsdf,fsdf/fsdf";
                                int start = 0;
                                int end = 0;
                                string s = " ,/";

                                start = str.find_first_not_of(s);
                                while(start != string::npos) {
                                        end = str.find_first_of(s, start+1);
                                        if(end == string::npos)
                                                end = str.length();

                                        cout << str.substr(start, end-start) << endl;

                                        start = str.find_first_not_of(s, end+1);
                                }

                                return 0;
                        }

（4）修改字符串
            （1）插入字符串
                （1）涉及成员函数：insert
                （2）不同重载版本
                    （1）word.inset(int i， string/char *str)：将字符串插入word的i之前
                    （2）word.inset(int i, string/char *str, int n)：将字符串插入str中前n个字符word的i之前
                    （2）word.inset(int i, string/char *str, int j, int n)：将字符串插入str中j位置开始的n个字符word的i之前

                （3）测试例子

            （2）字符串的替换
                （1）涉及成员函数：replace
                （2）涉及不同的重载版本
                    （1）word.replace(int i, int n, string/char * str);：将word中的i位置开始的n个字符，用str替换
                    （2）word.replace(int i, int n, string/char * str，int n1);：将word中的i位置开始的n个字符，用str中的前n1个替换
                    （3）word.replace(int i, int n, string/char * str，int i1, int n1);：将word中的i位置开始的n个字符，用str中i1位置开始的n1个字符替换。
                （3）用例


            （3）删除字符
                （1）涉及成员函数erase
                （2）重载版本
                    (1)word.erase(int i, int n);：将word中的i位置开始的n个字符删除

                （3）用例

    （5）字符串数组
        （1）c样式的字符串数组

        （2）c样式字符串数组
            char *p[] = {"hello", "world", "is", "buitful"};

        （3）string样式字符串              
            string p[] = {"hello", "world", "is", "buitful"};


        （4）二者的区别
            c样式的字符串数组中，字符串是常量，存放在常量区，内容不能被更改，否者会导致段错误。
            string样式字符串，字符串在string类中，是以字符串数组的形式存放的，内容是可以修改的。

        （5）用例

#include <stdio.h>
                #include <stdlib.h>
                #include <iostream>
                #include <string>

                using namespace std;
                int main(void)
                {
                        #if 0
                        char *p[] = {"hello", " world", " is", " buitful"};

                        p[0][1] = 'w';
                        #endif  

                        string p[] = {"hello", " world", " is", " buitful"};
                        p[0][1] = 'w';

                        cout << p[0] << endl;

                        return 0;
                }