C++基础 第3页

我们的第一个“Hello World”程序使用cout输出了"Hello World"这一句话其实就是字符串。字符串就是连续的字符“串”起来的一段文本，可以看成是若干有序的字符的集合。通过前面的学习，可知char数组就是若干有序的字符的集合，所以可以使用char数组来存储字符串。

一、字符串常量

回顾“Hello World”程序代码：cout<<"Hello World";，语句中的"Hello World"就是一个字符串常量。字符串常量书写的时候用英文双引号引起来，例如："Hello World"、"I love programming"、"In me\nthe tiger sniffs the rose."、"A"都是字符串常量。要注意"A"和'A'的区别，"A"是只包含一个字符的字符串，'A'是一个字符。

二、使用字符数组存储字符串

首先来回顾普通字符数组的用法。普通字符数组就是char类型的数组，数组元素的类型是char类型。

#include<iostream>
using namespace std;
int main()
{
    char s[6];
    //输入6个char存储到字符数组中 
    for(int i=0;i<=5;i++) cin>>s[i];
    //输出字符数组中的元素 
    for(int i=0;i<=5;i++) cout<<s[i];
    cout<<endl;
    //对字符数组中的元素进行重新赋值 
    s[0] = 'z';
    s[2] = s[1];
    s[3]++;
    for(int i=0;i<=5;i++) cout<<s[i];
    return 0; 
}

那么如何保存字符串变量呢？例如输入一个字符串，应该如何存储？字符串就是连续的字符“串”起来的一段文本，可以看成是若干有序的字符的集合，所以可以使用char数组来存储字符串。

例如语句 char str[6] = "Hello";，将字符串常量"Hello"存储到了长度为6的字符数组str中。语句执行后，字符数组str每个元素的情况如下：

可见字符串的每个字符按照顺序依次存储到字符数组中，特殊地是，存储字符串的字符数组末尾会自动加上一个“尾巴”——表示字符串结束的特殊字符'\0'（空字符，ASCII码值为0），这也是为什么"Hello"只有5个字符，却至少要用长度为6的字符数组来存储。这是C/C++的自动处理机制，C/C++是靠空字符'\0'来识别保存到字符数组中的字符串的结束位置。可以通过一个程序来测试：

#include<iostream>
using namespace std;
int main()
{
    char str[6] = "Hello";
    cout<<str<<endl;	//输出存储在字符数组中的字符串
	str[3] = '\0';	  //一句“恶意”代码
	cout<<str<<endl; 
    return 0; 
}

程序的运行结果如下：

Hello
Hel

执行了str[3] = '\0';语句后，str数组元素如下：

这个时候再用cout输出存储在字符数组str中的字符串，因为C/C++是靠空字符'\0'来识别保存到字符数组中的字符串的结束位置，所以会认为存储在str中的字符串是"Hel"，程序最后输出的内容也正是"Hel"。

通过上面的分析可知：

1. 可以使用字符数组存储字符串；
2. 存储时，从字符数组的 0 号下标开始依次存储字符串的每个字符。C/C++会自动在字符数组末尾的地方加上空字符'\0'，注意这是运行时自动实现的，不需要我们写代码去实现！
3. 正因为如此，定义存储字符串的字符数组时，数组的长度至少是要存储的字符串的长度+1。如果开的char数组很大，依次存储完字符串的所有字符后，字符数组后面的元素都是空字符'\0'。

三、输入输出字符串

使用字符数组存储字符串，可以直接使用cin将输入的字符串存入到字符数组中，此时也会自动在数组的末尾添加上空字符'\0'。也可以直接使用cout输出存储在字符数组中的字符串，会自动依次输出字符数组中的字符直到遇到'\0'为止（不会输出'\0'）。

例如我们要输入一句不包含空格、长度不超过10的英语单词，要将单词的字母全部大写，可以这样处理：

#include<iostream>
using namespace std;
int main()
{
    char str[11];  //输入的字符串长度不超过10，存储字符串的字符数组长度至少为11
    cin>>str;
    cout<<str<<endl;
    for(int i=0;str[i]!='\0';i++){   //使用循环遍历字符数组存储字符串的元素
    	//小写字母转大写
    	if(str[i]>='a' && str[i]<='z') str[i] -= 'a'-'A';
    	cout<<str[i];
	}
    return 0; 
}

如果输入的字符串长度小于10，例如输入"Hello"，那么字符数组内部的存储形式如下：

因为'\0'相当于整数0，所以还可以将遍历存储在字符数组中的字符串写成：

#include<iostream>
using namespace std;
int main()
{
    char str[11];  //输入的字符串长度不超过10，存储字符串的字符数组长度至少为11
    cin>>str;
    cout<<str<<endl;
    for(int i=0;str[i];i++){    //循环条件直接用s[i]
    	//小写字母转大写
    	if(str[i]>='a' && str[i]<='z') str[i] -= 'a'-'A';
	}
    cout<<str<<endl;  //前面循环中已经将char数组中的小写字母改成了大写字母
    return 0; 
}

关于字符串更多的输入输出方式，后面的章节会详细介绍。

四、字符串和字符数组的区别

1. 字符数组就是元素类型为char的数组；
2. 字符串可以存储在字符数组中。例如定义字符数组时赋初值为常量字符串、通过cin直接将字符串输入到字符数组、通过cout直接输出字符数组时，字符数组都会被当成字符串处理。存储的时候会自动在字符数组末尾添加上一个表示字符串结束的空字符'\0'。

五、字符串函数

其实应用程序中处理字符串的操作远远多于处理数字，就像cmath中有很多用来实现数学计算的函数一样，C/C++中提供了字符串处理函数来简化对字符串的基本处理，要使用这些函数，首先要引入cstring头文件。

1.strlen字符串长度

可以使用strlen函数求字符串的长度，参阅下面的程序：

#include<iostream>
#include<cstring>
using namespace std;
char str[1001];
int main()
{
    cin>>str;
    cout<<strlen(str)<<endl;
    int n = strlen(str);
    for(int i=0;i<n;i++){
    	cout<<str[i];
	}
    return 0; 
}

使用strlen函数求出字符串的长度，-1则是字符串最后一个元素的下标，这样可以实现反向遍历字符串：

#include<iostream>
#include<cstring>
using namespace std;
char str[1001];
int main()
{
    cin>>str;
    for(int i=strlen(str)-1;i>=0;i--){
    	cout<<str[i];
	}
    return 0; 
}

2.strcpy拷贝字符串

使用strcpy(s1,s2);可以将字符串s2的内容拷贝到s1中，注意这里没有返回值，是直接改变字符串s1的内容。例如要交换两个字符串的值，不能像数字那样使用交换器，可以使用strcpy来拷贝字符串：

#include<iostream>
#include<cstring>
using namespace std;
int main()
{
    char s1[11] = "Hello";
    char s2[11] = "World";
    cout<<s1<<" "<<s2<<endl;

    char tmp[11];
    strcpy(tmp,s1);
    strcpy(s1,s2);
    strcpy(s2,tmp);

    cout<<s1<<" "<<s2<<endl;
    return 0; 
}

3.strcat字符串拼接

使用strcat(s1,s2);可以将字符串s2的内容拼接到s1的末尾，注意这里没有返回值，是直接改变字符串s1的内容。

#include<iostream>
#include<cstring>
using namespace std;
int main()
{
    char s1[21] = "Hello";
    char s2[21] = "World";
    cout<<s1<<endl;

    strcat(s1,s2);
    cout<<s1<<endl;
    return 0; 
}

4.strcmp字符串比较

strcmp(s1,s2);函数返回使用字典顺序比较字符串s1、s2的结果，如果s1==s2，返回值是0；如果s1>s2，返回值大于0；如果s1<s2，返回值小于0。所谓字典顺序就是英语字典里单词的排列顺序，也和字符串中字符的ASCII值有关系。

#include<iostream>
#include<cstring>
using namespace std;
int main()
{
    cout<<strcmp("hello","hello")<<endl;
    cout<<strcmp("a","A")<<endl;   	 //"a">"A"
    cout<<strcmp("he","hello")<<endl;   //"he"<"hello"
    cout<<strcmp("H","h")<<endl;	    //"H"<"h"
    cout<<strcmp("Hello","h")<<endl;	//"Hello"<"h"
    cout<<strcmp("H","hello")<<endl;	//"H"<"hello"
    return 0; 
}

来看一段程序代码：

#include<iostream>
#include<cstring>
using namespace std;
int main()
{
    char choice[11];
    cin>>choice;
    //依次处理字符串中的char，大写字母转换成小写 
    for(int i=0;choice[i]!='\0';i++){
    	if(choice[i]>='A' && choice[i]<='Z'){
    		choice[i] += 'a'-'A';
		}
	}
    if(strcmp(choice,"yes")==0){
    	cout<<"you inputed yes";
	}
    return 0; 
}

5.memset初始化函数

memset是计算机中C/C++语言初始化函数。作用是将某一块内存中的内容全部设置为指定的值，这个函数通常为新申请的内存做初始化工作。我们一般用来将数组的元素全部赋值为同一个值，memset函数的处理速度优于用循环重复赋值。

#include<iostream>
#include<cstring>
using namespace std;
int main()
{
    int a[5];

    cout<<sizeof(a)<<endl;    //sizeof(a)计算数组a的字节长度，这里结果是20
    
    memset(a,0,sizeof(a));    //将int数组a的每个元素赋值为0
    for(int i=0;i<5;i++) cout<<a[i]<<" ";
    cout<<endl;
    
    memset(a,-1,sizeof(a));   //将int数组a的每个元素赋值为-1
    for(int i=0;i<5;i++) cout<<a[i]<<" ";
    cout<<endl;
    
    memset(a,1,sizeof(a));    //注意：这里并不能将int数组a的每个元素赋值为1
    for(int i=0;i<5;i++) cout<<a[i]<<" ";
    cout<<endl;
    return 0; 
}

程序运行结果如下：

20
0 0 0 0 0
-1 -1 -1 -1 -1
16843009 16843009 16843009 16843009 16843009

分析结果可知：memset(a,1,sizeof(a));并没有达到预期的将int数组a的所有元素赋值为1的效果。原因是memset是以字节为单位对连续内存空间赋值的，int是4个字节，每个int元素的每个字节会被赋值成0000001，那么每个int元素会被赋值为二进制数 00000001000000010000000100000001，也就是十进制数16843009。所以使用memset函数对int或者long long类型数组元素批量赋值，一般赋值成0或者-1能够达到效果，赋值为255也会被初始化为-1，其他值不能达到效果。对于int 或者long long类型数组，使用memset初始化，如果初始化成127，那么数组的每个元素会是接近 int 或long long类型上限的正整数；如果初始化成128，那么数组的每个元素会是接近 int 或long long类型下限的负整数；

如果我们将上面程序的int数组修改成char数组，那么能够将数组的元素批量赋值成-128～127范围内的任意整数，因为char正好是一个字节：

#include<iostream>
#include<cstring>
using namespace std;
int main()
{
    char a[5];    //char数组，每个元素一个字节 
    
    memset(a,0,sizeof(a));
    for(int i=0;i<5;i++) cout<<(int)a[i]<<" ";
    cout<<endl;
    
    memset(a,-128,sizeof(a));
    for(int i=0;i<5;i++) cout<<(int)a[i]<<" ";
    cout<<endl;
    
    memset(a,127,sizeof(a));
    for(int i=0;i<5;i++) cout<<(int)a[i]<<" ";
    cout<<endl;
    return 0; 
}

*6.memcpy内存拷贝函数

memcpy是C和C++使用的内存拷贝函数，函数使用方法是memcpy(destin,source,n);函数的功能是从源内存地址的起始位置开始拷贝若干个字节到目标内存地址中，即从源source中拷贝n个字节到目标destin中。与strcpy不同的是，strcpy只能复制字符串，而memcpy可以复制任意内容，例如任意类型数组、整型、结构体、类等。

#include<iostream>
#include<cstring>
using namespace std;
int main()
{
    int a[10] = {1,2,3,4,5,6,7,8,9,10};
    int b[10];
    
    memcpy(b,a,sizeof(a));
    
    for(int i=0;i<10;i++) cout<<b[i]<<" ";
    return 0; 
}

注意：有一些字符串函数，例如实现大小写转换的strlwr、strupr，不是标准C库函数，只能在Dev C++中使用，在竞赛标准的 Linux gcc 环境下不能使用。

使用字符数组来存储字符串，其实是C的做法，C++除了沿用这样的做法外，还引入了专门的数据类型string来处理字符串。string本质是类，所以有很多字符串处理方法。

因为string是C++中的类，而类是C++的高级用法，所以本节的内容有一定的难度，如果不能较好地理解，可以尝试先记忆介绍的使用方法。

一、C++中的string类型

C++中有专门的string类型来处理字符串，所以可以像int、double这些基本数据类型一样很简单地使用string类型存储字符串，使用string最好引入string头文件：

#include<iostream>
#include<string>
using namespace std;
int main()
{
    string s;
    cin>>s;
    cout<<s<<endl;
    return 0; 
}

需要特别注意的是，通过 cin 输入 string，与 cin 输入数字相同，默认的分割符号是空格、回车、制表符，所以上面的程序如果输入Hello World，字符串 s 的结果是Hello，只会把空格前的内容输入到字符串 s 中。如果想将有空格的内容全部输入到字符串中，可以使用 getline(cin,s);，这样可以将一整行的内容输入到字符串中 。

二、使用string中的某个字符

可以像使用数组下标访问数组元素那样通过下标来使用string中的某个字符，不仅仅是取出来使用，甚至可以修改：

#include<iostream>
#include<string>
using namespace std;
int main()
{
    string s = "Hello";
	cout<<s<<endl;

	cout<<s[0]<<s[1]<<s[2]<<s[3]<<s[4]<<endl;

	s[0] = 'X'; 
	cout<<s<<endl;    
    return 0; 
}

三、string与字符数组字符串的相互转换

C使用字符数组来存储字符串，C++除沿用这样的方法外，还有专门的string类型来处理字符串。可以通过代码来相互转换：

#include<iostream>
#include<cstring>
#include<string>
using namespace std;
int main()
{
    char str[15] = "Hello World";
	string s(str);  //使用字符数组初始化string 
	cout<<s<<endl;
	
	s = "Hi";
	//s.c_str()方法返回string变量s的字符数组存储形式
	//再通过strcpy函数拷贝到str数组中 
	strcpy(str,s.c_str());
	cout<<str<<endl;
    return 0; 
}

四、string常用方法

1.string相比较char数组存储字符串的优势

string可以认为是一种数据类型，支持string变量直接赋值成另一个变量：

#include<iostream>
#include<string>
using namespace std;
int main()
{
    string s = "Hello";
	string ss = s;
	cout<<ss;    
    return 0; 
}

string类型支持+运算，表示字符串拼接：

#include<iostream>
#include<string>
using namespace std;
int main()
{
    string s = "Hello";
	cout<<s+" World"<<endl;
	s += " World";
	cout<<s<<endl;
    return 0; 
}

string类型支持>、>=、<、<=、==、!=这些比较运算，string字符串比较时规则和char数组存储的字符串规则一致：

#include<iostream>
#include<string>
using namespace std;
int main()
{
    string s;
    cin>>s;
    if(s=="yes") cout<<"you inputed YES";
    return 0; 
}

2.string的初始化

string本质是类，有丰富的构造函数（后面会有所介绍），所以初始化string变量的方式很多：

#include<iostream>
#include<string>
using namespace std;
int main()
{
    string s1 = "Hello";    //通过赋值语句初始化
    cout<<s1<<endl;
    
    string s2("Hello");     //用字符串常量初始化
    cout<<s2<<endl;
    
    string s3(s2);          //用其它字符串变量初始化
    cout<<s3<<endl;
    
    char str[6] = "Hello";
    string s4(str);         //用存储在字符数组的字符串初始化
    cout<<s4<<endl;
    return 0; 
}

3.string字符串长度

使用string的length方法或者size方法都能获取字符串的长度。使用方法参见下面的程序：

#include<iostream>
#include<string>
using namespace std;
int main()
{
	string s;
	cin>>s;
	cout<<s.length()<<endl;		//使用length方法获取字符串长度 
	cout<<s.size()<<endl;		  //使用size方法获取字符串长度
	
	//与string长度相关的变量可以使用int类型，但推荐使用size_t或者string::size_type
	size_t n = s.length();		 //使用size_t类型变量存储获取到的字符串长度
	//使用size_t类型控制变量遍历string的每个字符 
	for(size_t i = 0;i<n;i++){
		cout<<s[i];
	}
    return 0; 
}

4.遍历string所有元素

可以使用for循环来依次枚举string元素的下标，实现正向以及逆向遍历string的元素：

#include<iostream>
#include<string>
using namespace std;
int main(){
	string s;
	cin>>s;
	//size_t 在标准Linux环境下本质上是 unsigned long long（无符号长整型）
	//正向遍历
	for(size_t i = 0;i<s.length();i++)
		cout<<s[i];
	cout<<endl;
	
	//反向遍历：控制变量是size_t类型，这里循环条件不能用 i>=0
	//原因是当size_t类型变量i值为0时，执行i--后，i值会变成很大的一个整数（string::npos）
	//所以这里条件用 i!=string::npos
	for(size_t i = s.length()-1;i!=string::npos;i--)
		cout<<s[i]; 
	cout<<endl;
	return 0;
} 

还可以使用STL（标准模版库）中的迭代器实现string元素的遍历（后续进阶学习内容）：

#include<iostream>
#include<string>
using namespace std;
int main(){
	string s;
	cin>>s;
	
	//正向遍历 
	string::iterator it = s.begin(); 
	for(;it != s.end();it++)
		cout<<*it;
	cout<<endl;
	
	//反向遍历 
	string::reverse_iterator rit = s.rbegin(); 
	for(;rit != s.rend();rit++)
		cout<<*rit;
	cout<<endl;
	return 0;
} 

*5.修改string内容

可以通过多种语句或者调用方法修改string的内容：

#include<iostream>
#include<string>
using namespace std;
int main ()
{
    string s = "Hello World";
    cout<<1<<":"<<s<<endl;
    
    //通过下标方式修改字符串某个字符，字符串也会变化 
    s[5] = '+'; 
    cout<<2<<":"<<s<<endl; 
    
    //assign方法重新赋值，效果与 s="Nice to meet you";一致，但执行方式不同 
    s.assign("Nice to meet you");
	cout<<3<<":"<<s<<endl; 
	
	string st="Hello";
	//swap方法交换s与st的值
	s.swap(st); 
	cout<<4<<":"<<s<<" "<<st<<endl; 
	
	//append方法末尾追加字符串
	//效果与 s = s+" World";或者 s+=" World";一致，但执行方式不同 
	s.append(" World");
	cout<<5<<":"<<s<<endl;
	
	//push_back方法在字符串末尾追加字符 
	s.push_back('!');
	cout<<6<<":"<<s<<endl;
	
	//insert方法在字符串中插入字符串 
	//在第0个字符前插入字符串 
	s.insert(0,"Say ");
	cout<<7<<":"<<s<<endl;
	
	//replace方法替换字符串指定区间的内容
	//s从第4个开始的一共5个字符被替换成"Hi"
	s.replace(4,5,"Hi"); 
	cout<<8<<":"<<s<<endl;
	//s从第0个开始的一共4个字符被替换成""，实现的是删除的效果 
	s.replace(0,4,""); 
	cout<<9<<":"<<s<<endl;
	
	//erase方法删除字符串指定区间的所有字符
	//从第2个字符开始总共删除6个字符
	s.erase(2,6); 
	cout<<10<<":"<<s<<endl;
	
	//clear方法清空字符串，变成空字符串"" 
	s.clear();
	cout<<11<<":"<<s<<endl;
	cout<<12<<":"<<s.size()<<endl;

    return 0;
}

程序运行结果如下：

1:Hello World
2:Hello+World
3:Nice to meet you
4:Hello Nice to meet you
5:Hello World
6:Hello World!
7:Say Hello World!
8:Say Hi World!
9:Hi World!
10:Hi!
11:
12:0

*6.字符串查找方法

string有丰富的字符串查找方法，包括find、rfind、find_first_of、find_last_of、find_first_not_of、find_last_not_of等方法可以实现丰富的查找：

#include<iostream>
#include<string>
using namespace std;
int main ()
{
    string s = "Hello World";
    
    //在s中查找字符'o'的位置
    cout<<1<<":"<<s.find('o')<<endl;
    
    //在s中从第5个字符开始查找字符'o'的位置
	cout<<2<<":"<<s.find('o',5)<<endl;
	
	//在s中查找字符串"or"出现的位置
	cout<<3<<":"<<s.find("or")<<endl;
	
	//在s中从第8个字符查找字符串"or"出现的位置，查不到返回string::npos
	cout<<4<<":"<<s.find("or",8)<<endl;
	if(s.find("or",8)==string::npos)
		cout<<5<<":"<<"Not found"<<endl;
	
	//在s中逆向查找字符'o'的位置
	cout<<6<<":"<<s.rfind('o')<<endl;
	
	//在s中从第5个字符开始，逆向查找字符'o'的位置
	cout<<7<<":"<<s.rfind('o',5)<<endl;
	
	//在s中逆向查找字符串"or"出现的位置
	cout<<8<<":"<<s.rfind("or")<<endl;
    return 0;
}

程序运行结果如下：

1:4
2:7
3:7
4:4294967295
5:Not found
6:7
7:4
8:7

#include<iostream>
#include<string>
using namespace std;
int main ()
{	
	string str("This is one string for example");
	
	//str中第一个字符'i'出现的位置
	cout<<1<<":"<<str.find_first_of('i')<<endl;
	
	//str中从第3个字符开始，第一个'i'出现的位置
	cout<<2<<":"<<str.find_first_of('i',3)<<endl;
	
	//字符串"oiehtT"任意一个字符在str中第一次出现的位置
	cout<<3<<":"<<str.find_first_of("oiehtT")<<endl;
	
	//从第3个字符开始，字符串"oiehtT"任意一个字符在str中第一次出现的位置
	cout<<4<<":"<<str.find_first_of("oiehtT",3)<<endl;
	
	//逆向查找：str中第一个字符'e'出现的位置
	cout<<5<<":"<<str.find_last_of('e')<<endl;
	
	//逆向查找：字符串"le"中任意一个字符在str中第一次出现的位置 
	cout<<6<<":"<<str.find_last_of("le")<<endl;
    return 0;
}

程序运行结果如下：

1:2
2:5
3:0
4:5
5:29
6:29

#include<iostream>
#include<string>
using namespace std;
int main ()
{	
	string str = "iiiiekpkiiieylmnqqqqq";
	
	//str中第一个不是'i'的字符的位置
	cout<<1<<":"<<str.find_first_not_of('i')<<endl;
	
	//str中第一个不是"eik"字符串中任意字符的位置
	cout<<2<<":"<<str.find_first_not_of("eik")<<endl;
	
	//str中从第7个字符开始查找第一个不是"eik"字符串中任意字符的位置 
	cout<<3<<":"<<str.find_first_not_of("eik",7)<<endl;
	
	//逆向查找：str中第一个不是字符'q'的字符出现的位置
	cout<<4<<":"<<str.find_last_not_of('q')<<endl;
	
	//逆向查找：str中第一个不是字符串"nqm"的任意字符出现的位置
	cout<<5<<":"<<str.find_last_not_of("nqm")<<endl;
    return 0;
}

程序运行结果如下：

1:4
2:6
3:12
4:15
5:13

*7.获取字符串子串

可以通过string的substr方法获取字符串的子串（连续的一部分）

#include<iostream>
#include<string>
using namespace std;
int main()
{
	string s = "Hello World";
	cout<<s<<endl;
	
	//从s下标2开始直到结尾的子串 
	string s1 = s.substr(2);	//结果是:llo World
	cout<<s1<<endl;
	
	//从s下标2开始，长度为5的子串 
	string s2 = s.substr(2,5);	//结果是:llo W 
	cout<<s2<<endl; 
	
	//从s下标0开始直到结尾的子串 
	string s3 = s.substr(0);	//结果是:Hello World
	cout<<s3<<endl;
	return 0;
}

通过前面的学习可知，可以使用字符数组来存储字符串，也可以直接使用C++的string类型来存储字符串。但是如果要按行输入带有空格的字符串，只是简单地使用cin和scanf是不能实现的。

本小节重点研究字符串的输入，重点处理按行输入有空格的字符串的情况。

现实生活中，编程解决实际问题时，要处理的字符和字符串数据其实远多于数字类型；在信息学竞赛中，字符串的处理也是一个重点。

一、字符串的输入输出

不管是用字符数组存储字符串还是直接使用C++的string类型存储字符串，都可以使用cin输入字符串、cout输出字符串：

#include<iostream> 
using namespace std;
int main()
{
    char str[1010];
    cin>>str;
    cout<<str<<endl;
    return 0;
}

#include<iostream>
#include<string> 
using namespace std;
int main()
{
    string str;
    cin>>str;
    cout<<str<<endl;
    return 0;
}

不能使用scanf和printf输入输出string类型字符串，但是可以使用scanf和printf输入输出存储在字符数组中的字符串，还可以使用puts函数输出存储在字符数组中的字符串：

#include<cstdio>
int main()
{
    char str[1010];
    scanf("%s",str);  //不能用&str 
    printf("%s\n",str);
    puts(str);	    //puts函数输出字符串，输出字符串后会自动换行 
    return 0;
}

二、按行输入有空格的字符串

不管是使用scanf还是cin输入字符串，空格依然是多个数据间的分隔符，如果想输入一行包括空格的字符串，直接简单地使用scanf和cin是不能实现的，还是上面的代码：

#include<iostream> 
using namespace std;
int main()
{
    char str[1010];
    cin>>str;
    cout<<str<<endl;
    return 0;
}

#include<iostream>
#include<string> 
using namespace std;
int main()
{
    string str;
    cin>>str;
    cout<<str<<endl;
    return 0;
}

想输入一行包括空格的文本，例如Hello World，运行程序，输入Hello World，输出结果都是Hello，可知str只接收到了Hello World空格前的Hello。那么如何按行输入有空格的字符串呢？

1.使用字符数组存储字符串的情况

与puts函数输出用字符数组存储的字符串相对应的是，使用gets函数将字符串输入到字符数组中保存，gets函数能够按行输入，即使行内有空格也不受影响：