编程语言学习(六) 三种编程语言的字符串

（一）C语言字符串

(1) 字符串的本质

就是以整数0结尾的字符数组，比如 char a[]={'h','e','l','l','o',0};

(2) 字符串字面量

实际上是字符数组，长度是可见长度加一。

两个相邻的字符串字面量会被连接起来。：

printf("ni hao a"" wo shi xls ");  //输出ni hao a wo shi xls
printf("ni hao a"" wo shi\      //带有反斜杠的字面量，表示下一行还有
xls ");          //下一行务必顶格，不然输出中会空出一些空格

(3) 字符串变量

可以有三种形式：

char a []=”xxxxx”;   //字符数组型
char a[10]=”xxxx”;//指定大小的字符数组型
char* a=”xxxxxxx”;   //字符指针型

第一种：字符串字面量存储在栈区，字符数组包含这些字节，字节数是内容数+1，可以改变其各字节的值，适合对字符串进行操作。

第二种：与第一种相同，就是多出了一些空余的空间。

第三种：这样的字符串字面量实际上是存储在“常量区”，指针在栈区指向常量区，正是由于是常量区，所以char* a实际上是const char*a，是一个常量指针，但是由于历史的原因，编译器接受这个const的省略。适合于由malloc得到的字符串，以及作函参数。

char *a;
scanf("%s",a); //这样的代码是绝对不能出现的。

PS：C/C++字符串涉及到的内存分配知识：

 一个由C/C++编译的程序占用的内存分为以下几个部分

1、栈区（stack）— 由编译器自动分配释放 ，存放函数的参数值，局部变量的值等。其

操作方式类似于数据结构中的栈。

2、堆区（heap） — 一般由程序员分配释放， 若程序员不释放，程序结束时可能由OS回

收 。注意它与数据结构中的堆是两回事，分配方式倒是类似于链表，呵呵。

3、全局区（静态区）（static）—，全局变量和静态变量的存储是放在一块的，初始化的

全局变量和静态变量在一块区域， 未初始化的全局变量和未初始化的静态变量在相邻的另

一块区域。 - 程序结束后由系统释放。

4、文字常量区 —常量字符串就是放在这里的。 程序结束后由系统释放

5、程序代码区—存放函数体的二进制代码。

细节知识可以见点击打开链接 (我不知道这样算不算侵权...)

(4) 字符串处理函数：

需要知道的字符串处理函数有6个，它们都在<string.h>头文件下：

           函数原型                                 实现原理                     返回
size_t strlen(const char* s)                  从头遍历到\0为之，\0本身不算        长度
int strcmp(const char*s1,const char*s2)       逐个ACII码相减，直到不等           0,+1,-1
char* strcpy(char*dst,const char*src)         从src处复制字符到dst              新字符串
char* strcat(char*dst,const char*src)         从src处复制字符串到dst末尾         新字符串
char* strchr(const char*s,int c)              从左寻找第一个字符c                c的指针
char* strrchr(const char*s,int c)             从右寻找第一个字符c                c的指针
char* strstr(const char*s1,const char*s2)     从左寻找第一个字符串s2             s2的指针
char* strrstr(const char*s1,const char*s2)    从右寻找第一个字符串s2             s2的指针

带n版本的三个函数：

int strncmp(const char*s1,const char*s2,size_t n)    //只比较前n个字符
char* strncpy(char*dst,const char*src，size_t n)  //最多只复制n个字符过去
char* strncat(char*dst,const char*src)    //最多只连接n个字符过去

实现一览：

#include <stdio.h>
#include <string.h>
#include <malloc.h>    //这个不能是动态分配内存用的
 int stracmp(const char*s1,const char*s2){
 while(*s1==*s2&&*s1!='\0'){
     s1++;
     s2++;
      };
 return *s1-*s2;
 }

 int stralen(const char*s1){
int num=0;
while(*s1++){
    num++;
    }
return num;
}

char* stracpy(char *dst,const char*src){
    int index=0;
    char* c=dst;
    while(*dst++=*src++);
    *dst=0;
    return c;
}

char *stracat(char*dst,const char*src){
    char*c =dst;
    int num=stralen(dst);
    return (stracpy(dst+stralen(dst),src)-num);
}

int main(){
char a[30]="ni hao a,mm ";
char *c=(char*)malloc(sizeof(char)*strlen(a)+1);  //申请了一段内存
strcpy(c,a);  //c是新的字符串 ，刚好复制过去 保存好了a字符串的原始状态
char b[30]="da sha bi qq";
char *d=stracat(a,b); //d是增长的字符串
printf("c是新的字符串：c=%s\n",c);
printf("d是增长的字符串：d=%s\n",d);
printf("我的strcmp二者比较：%d\n",stracmp(c,d));
printf("strncmp二者比较：%d\n",strncmp(c,d,18));
free (c);  //释放内存
c=0;   //指针调成空指针
return 0;
}

控制台界面：

c是新的字符串：c=ni hao a,mm
d是增长的字符串：d=ni hao a,mm da sha bi qq
我的strcmp二者比较：-100
strncmp二者比较：-1

（二）C++语言字符串

字符数组，也称C风格的字符串在C++当中同样支持，也包括一些列strlen、strcpy、strcmp、strcat、strchr等等，但是头文件一般采用<cstring>,其他和C语言是一样的。

C++标准类库里还提供了<string>类，提供了字符数组向string对象转化的构造方法，重载了一些运算符，并提供了一些成员函数供使用。

重要的构造方法：  //用于字符数组向string对象的转化

1. string(const char*s) //基于指针所指向的字符串构造string类的对象

2. string(const char*s,unsigned int posi,unsigned int n) //从第posi下标开始取n个字符构建string对象

3. string(const char*s,unsigned int n) //从头开始取n个字符构建string对象

 

重要的运算符重载：   //用于string对象之间的操作

1. s+t //将串s与串t连接形成新串

2. s=t //用串t来更新s

3. s+=t //将s与t连成的新串来更新s

4. >,>=,<,<=,==,!=如字面意思，可以发挥strcmp的作用

5. s[i] //相当重要，可以发挥字符数组般获取某个位置的字符的作用

 

重要的成员函数：    //用于string对象与字符数组/string对象之间的操作

1. string append(const char*s) //在已有string对象后面添加新字符串

2. string assign(const char*)  //用s所指的字符数组更新本对象

3. int compare(const string&str)const //比较两个string对象的大小

4. string& insert(unsigned int p0,const char*s)  //在本川当中p0下标前插入字符串

5. string substr(unsigned int pos,unsigned int n) const //从第pos位置开始取n个生成字符串返回

6. unsigned int length() const     //返回字符串的的长度

7. void swap(string& str)     //交换两个字符串对象 似乎不太重要。

8. size_type find(const char * s, size_type pos = 0) const //找到第一个合适的字符串首字符下标

实战代码：

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

int main() {
char a[30] = "0123456789";  //10个字符
char b[30] = "abcdefghij";
char c[30] = "qqqqqqqqqq";

//第一步 实战string类的构造函数

cout << "--------step 1:constructor---------" << endl;

string A(a);
string B(b, 4);
string C(a, 2, 3);  

cout << A << endl;
cout << B<< endl;
cout << C << endl;//从下标2开始，拿三个字符 C就是234

//第二步 实战运算符重载

cout << "--------step2:operator-------------" << endl;
cout << A + B << endl;
cout << (A += B) << endl;    //A被更新过了
cout << (A > B) << endl;//a是97 A是65 0是32 小写字母明显大
cout << A[10] << endl;//也就是第11个字符，是 b字符串贡献的第一个字母a
cout << "---------step 3:member function-------" << endl;

//第三步 实战string类成员函数

cout << B.append(B) << endl;//B原来只有4个字符 变成8个
cout << B.append(a) << endl;//对于char*做参数也可以继续添加

cout << B.assign(C) << endl;   //更新为_ha 可见在string类的参数里 char*和string的对象具有同等地位
cout << B.assign(c) << endl;   //更新为qqq

cout << B.compare(A) << endl;//B是qqqqqqq A是0123456789abcd q比0大一些

cout << B.insert(2, A) << endl;// 第三个q之前插入内容

cout << B.length() << endl; 

cout << B.substr(2, 14) << endl;  //重新被我截取出来了

cout << endl;

cout << "------the following content tell us how the swap functions:-------" << endl;

cout << B << endl;
B.swap(A);
cout << B<< endl;  //B变成了A

cout << A.find("qqq") << endl;    //find功能 展现第一个出现位置的下标

return 0;

}

控制台：

--------step 1:constructor---------
0123456789
abcd
234
--------step2:operator-------------
0123456789abcd
0123456789abcd
0
a
---------step 3:member function-------
abcdabcd
abcdabcd0123456789
234
qqqqqqqqqq
1
qq0123456789abcdqqqqqqqq
24
0123456789abcd
------the following content tell us how the swap functions:-------
qq0123456789abcdqqqqqqqq
0123456789abcd
16

（三）Java语言字符串

        不同于C/C++,Java的字符串时Unicode字符序列，所以顺利支持中文，C语言当中字符串时字符数组，可以有两者存在形式，若是以char*a=”xxxx”的形式存在的字符串，字符串本体是置于常量区而无法更改的，程序运行过程中动态创建的字符串也是如此。另一种字符串则是以char[int]=“xxxx”来实现的，是可以修改的。C++的string类是对字符数组的包裹，因为是参数传入string的构造函数，所以无论是char[]还是char*都是一视同仁的，也是不去修改字符串本体的，所谓的截取只是创造新串而已。

        Java的字符串就完全抛弃了字符数组包括字符的方式，因为java本身是引用类型都是动态分配内存得到，所以是遵循第一种生成方式的，所以java的字符串也具有了不可变性。也就是两个引用若是指向相同字符串，实际上只有一个字符串给二者共享。

        C++的字符串实际上是对字符数组的打包，而JAVA则是完全的面向对象，所以Java中有一个NULL的概念是C++没有的。Java中一个字符串可以是null，我们常用：

if(a!=null&&a.length()!=0) {    //既非空字符串””,也非null
System.out.println(a);
}

Java不支持运算符重载，所以一切的操作都是由类的方法实现的，对比C++我们列一个对照表：

功能	C语言实现	C++实现	Java实现
字符串长度	strlen	length()方法	length()方法
字符串比较	strcmp /strncmp	对象间：关系运算符 非对象：compare函数	int compareTo(String t) 方法
字符串相等	==是比较首字节的地址	对象之间：==运算符	==是比较对象的地址，改用.equals(String t) 方法
字符串更新	strcpy/ strncpy	对象间：=,+= 非对象：assign，insert	都是对象，请直接写“xxxx”，StringBuilder类有额外方法
字符串连接	strcat/ strncat	对象间：+ 对象与字符数组间：append	字符串都是对象，用+，甚至非字符串也适用
字符(串)寻找	strstr/ strrstr	find(const char*s,unsigned int posi=0)	indexOf(String str,int fromIndex)
字符串截取	一般是通过在所需字符串后一个字符先置0，再加引用，再恢复来实现的	string类带有： string substr(unsigned int posi,unsigned int n) const 函数	自带有：substring(int posi,int n)方法
字符定位	S[index]	无论字符数组还是对象，都支持S[index]	丧失了数组的性质，只能用方法 char charAt(int n)

 

Java由于字符串的不变性，其append方法，insert方法都不能用了，不过提供了StringBuilder类来解决这个问题，StringBulider类源自StringBuffer方法，较StringBuffer方法的效率降低，但是支持多线程增删字符，所以我们以后只用stringbuilder类即可，虽然二者的API是一样的。

重要API一览：

1. 构造方法：

StringBuilder()  //可以有string对象作参数，也可无参以后append添加

2. 字符串连接：

StringBuilder append(String s或者char c)    //尾部跟上新的字符或字符串

3. 改字符方法：

void setCharAt(int pos,char c)     //修改pos下标的字符为c

4. 字符串插入

StringBuilder insert(int pos,String str或char c)     //前面pos个字符保留，后面插入字符或者字符串

5. 字符串删除

StringBulider delete(int startIndex,int endIndex)   //两个下标直接删除内容

 

PS；C++当中其实也有插入单个字符的，就是insert(unsigned posi,unsigend num,char c);就是前面保留posi个字符，然后插入num个字符