1.设计并测试一个函数，可以从输入读取n个字符（包括空格、制表符和换行符），把结果存储在一个数组中，这个数组的地址通过参数来传递。
#include <stdio.h>
#define MAX 81
void getnc(char input[],int n);
int getnumber();
int main(void){
int n;//记录输入字符的个数
char str[MAX];//用于存储输入的字符串
printf("请填写要输入字符的个数:");
n=getnumber();
printf("请输入%d个字符，多余字符将被忽略:",n);
getnc(str,n);
printf("您输入的字符串为:%s",str);
return 0;
}
//题目要求的函数
void getnc(char input[],int n){
int i;
for(i=0;i<n;i++){
input[i]=getchar();
}
input[i]='\0';
}
//获得一个正整数函数
int getnumber(){
int n;
while(scanf("%d",&n)!=1 || n<=0){//若输入不是一个正整数，则重复输入，直到输入正整数为止
while(getchar()!='\n'){//将流中无效字符读入程序，避免重复错误读
continue;
}
printf("您没有输入正整数，请重新输入:");
}
//程序能走到这里，说明用户已经输入正整数，但仍需要处理有效数字后的内容，如：4abc这样的输入
while(getchar()!='\n'){
continue;
}
return n;
}
2.修改并测试练习1中的函数，使得可以在n个字符后，或第一个空格、制表符、换行符后停止读取输入，由上述情况最先被满足的那个终止读取（不能用scanf()函数）。
#include <stdio.h>
#include <stdlib.h>
#include <ctype.h>
#define MAX 30 //数字字符串长度
#define CHARMAX 81//字符串长度
void getnc(char input[],int n);
int getnumber();
int main(void){
char str[CHARMAX];//用于存储用户输入的字符串
int value;//待输入的字符个数
value=getnumber();
printf("请输入%d个字符，输入空格、制表符、换行符则终止读取:",value);
getnc(str,value);
printf("您输入的字符串为%s",str);
return 0;
}
//题目要求的函数
void getnc(char input[],int n){
int i;
for(i=0;i<n;i++){
input[i]=getchar();
if(isspace(input[i]))//如果输入的字符是空格、制表符、换行符则终止读取
break;
}
input[i]='\0';
}
//获得一个正整数函数，不适用scanf()实现
int getnumber(){
char number[MAX];//存放输入的数字字符串
int n; //存放数字字符串的int表示
char * end;//在调用strtod()时，用于指向第一个非数字字符的地址
printf("请输入字符个数:");
gets(number);
n=strtod(number,&end);//将数字字符串转换为整数类型
while(end==number || n<=0){//如果end==number明没有输入有效数字， n<=0则表明输入的是非整数不符合题意
printf("没有输入正整数，请重新输入:");
gets(number);
n=strtod(number,&end);
}
return n;
}
3.设计并测试一个函数，其功能是读取输入行里的第一个单词到数组，并丢弃该行中其它字符。一个单词的定义是一串字符，其中不包含空格、制表符、换行符。
#include <stdio.h>
#include <string.h>
#define MAX 80
int main(void){
char input[MAX];//用于存储输入行字符串
char word[MAX];//用于存储第一个单词
char * space,* table;//分别存储输入行中第一次出现的空格、制表
printf("请输入字符串:");
gets(input);//用gets行数不会读入换行符
space=strchr(input,' '); //找到第一个空格符的地址
table=strchr(input,'\t');//找到第一个制表符的地址
printf("space=%p,table=%p\n",space,table);
if(space>table){
if(table!=NULL)
*table='\0';
}
else{
if(space!=NULL)
*space='\0';
}
//strcpy(word,input);
printf("第一个单词是:");
puts(word);
return 0;
}
4.设计并测试一个函数，其功能是搜索由函数的第一个参数指定的字符串，在其中查找由函数的第二个参数指定的字符的第一次出现的位置。如果找到，返回指向这个字符的指针；如果没有找到，返回空字符（这种方式和strchr()函数功能一样）。在一个使用循环语句为这个函数提供输入的完整程序中进行测试。
#include <stdio.h>
#include <string.h>
#define MAX 80
char * searchFirstChar(char * source,char target);
int main(void){
char input[MAX];//源字符串
char target;//需要查询的目标字符
char * targetPoint;//保存目标字符在源字符串中的地址
while(1){
printf("请输入源字符串，输入quit退出程序:");
gets(input);
while(input[0]=='\0'){
printf("您未输入任何内容，请重新输入，输入quit退出程序:");
gets(input);
}
if(strcmp(input,"quit")==0)
break;//跳出循环，程序结束
printf("请输入要查询的目标字符:");
target=getchar();
while(target=='\n'){
printf("您未输入任何字符，请重新输入:");
target=getchar();
}
while(getchar()!='\n')//目标字符之后所有的内容将被丢弃
continue;
targetPoint=searchFirstChar(input,target);
if(*targetPoint=='\0'){//没有查询到目标字符
printf("源字符串%s中不包含目标字符%c!\n",input,target);
}else{
printf("源字符串%s中目标字符%c的存储地址是%p!\n",input,target,targetPoint);
}
}
printf("程序结束!");
return 0;
}
//查找目标字符首次出现的位置
char * searchFirstChar(char * source,char target){
char * point;//从字符串首个字符依次向字符串末尾移动
point=source;//将参数字符串的一个字符地址赋值给point
while(*point){//字符串以'\0'结尾，该条件表明不是空字符就没有到达字符串末尾，需要继续查找
if(*point==target)//找到目标字符，并返回其指针
return point;
point++;
}
//循环执行完而没有结束函数说明没有找到目标字符，返回空字符
return "\0";//不能直接返回空字符，如:return '\0'
}
5.编写一个函数is_within()。他接收两个参数,一个是字符，另一个是字符串指针。其功能是如果字符在字符串中，就返回一个非0值（真）；如果字符不在字符串中，就返回0值（假）。在一个使用循环语句为这个函数提供输入的完整程序中进行测试。
#include <stdio.h>
#include <string.h>
#define MAX 80
int is_within(char * sourceStr,char targetCh);
char * getInputStr(char * input);
char getTargetChar();
int main(void){
char sourceStr[MAX];
char targetCh;
while(1){
printf("请输入源字符串，输入quit结算程序:");
getInputStr(sourceStr);
if(strcmp(sourceStr,"quit")==0)
break;//输入quit则程序结束
printf("请输入要查询的目标字符:");
targetCh= getTargetChar();
if(is_within(sourceStr,targetCh)){
printf("字符%c在串%s里!\n",targetCh,sourceStr);
}else{
printf("字符%c不在在串%s里!\n",targetCh,sourceStr);
}
}
printf("程序结束!");
return 0;
}
//题求函数
int is_within(char * sourceStr,char targetCh){
if(strchr(sourceStr,targetCh))
return 1;
else
return 0;
}
//获得源字符串
char * getInputStr(char * input){
gets(input);
while(input[0]=='\0'){
printf("您未输入任何内容，请重新输入:");
gets(input);
}
return input;
}
//获得目标字符函数
char getTargetChar(){
char target;//存储要查询的目标字符
target=getchar();
while(target=='\n'){
printf("您未输入任何字符，请重新输入:");
target=getchar();
}
while(getchar()!='\n')//目标字符之后所有的内容将被丢弃
continue;
return target;
}
6.strncpy(s1,s2,n)函数从s2复制n个字符给s1，并在必要时截断s2或为其填充额外的空字符。如果s2的长度等于或大于n，目标字符串就没有标志结束的空字符。函数返回s1。自己编写这个函数，并在一个使用循环语句为这个函数提供输入的完整程序中进行测试。
#include <stdio.h>
#include <string.h>
#define MAX 80
char * myStrncpy(char * target,char * source,int n);
int main(void){
char source[MAX];
char target[MAX];
int n;//要拷贝的字符个数
while(1){
printf("请输入源字符串，输入quit结束程序:");
gets(source);
if(strcmp(source,"quit")==0)
break;//程序结束
while(source[0]=='\0'){
printf("您未输入任何字符，请重新输入:");
gets(source);
}
printf("请输入要拷贝的字符数,不能超过目标字符串的长度%d:",sizeof(target)-1);
while(scanf("%d",&n)!=1 || n>sizeof(target)-1){
printf("输入错误，请重新输入要拷贝字符个数，不超过%d:",sizeof(target)-1);
while(getchar()!='\n')
continue;//清除无效输入
}
while(getchar()!='\n')
continue;//清除无效输入
myStrncpy(target,source,n);
printf("target is %s\n",target);
}
printf("程序结束!");
return 0;
}
//题求函数，n的值须至少比target字符串长度小1，该要求由调用者自己控制
char * myStrncpy(char * target,char * source,int n){
int num;//记录最终可以从原字符串拷贝到目标字符串的字符数
char * targetPoint,* sourcePoint;//targetPoint,sourcePoint分别是目标字符串和原字符串的工作指针
int i;//循环计数器
targetPoint=target;//初始化工作指针
sourcePoint=source;
if(n>strlen(source)){//如果n的值大于源字符串长度，则源字符串可全部复制
num=strlen(source);
}else{//若n的值不大于源字符串长度，则只能复制n个字符
num=n;
}
for(i=0;i<n;i++){
*targetPoint=*sourcePoint;//拷贝字符
targetPoint++;
sourcePoint++;
}
*targetPoint='\0';
return target;
}
7.编写一个函数string_in()，它接受两个字符串指针参数。如果第二个字符串被包含在第一个字符串中，函数返回被包含的字符串开始的地址。例如，string_in(“hats”,”at”)返回hats中a的地址，否则，函数返回空指针。在一个使用循环语句为这个函数提供输入的完整程序中进行测试。
#include <stdio.h>
#include <string.h>
#define MAX 80
char * string_in(char * source,char * target);
int main(void){
char sourceStr[MAX];
char targetStr[MAX];
while(1){
printf("请输入源串，输入quit结束程序:");
gets(sourceStr);
while(*sourceStr=='\0'){
printf("您未输入任何内容，请重新输入,输入quit结束程序:");
gets(sourceStr);
}
if(strcmp(sourceStr,"quit")==0)//结束程序
break;
printf("请输入目标子串:");
gets(targetStr);
while(*targetStr=='\0'){
printf("您未输入任何内容，请重新输入:");
gets(targetStr);
}
if(string_in(sourceStr,targetStr)==NULL){
printf("源串%s中不包含目标子串%s\n",sourceStr,targetStr);
}else{
printf("目标子串%s在源串%s的%p位置\n",targetStr,sourceStr,string_in(sourceStr,targetStr));
}
}
printf("结束程序!");
return 0;
}
char * string_in(char * source,char * target){//source源字符串，在原字符串中被搜索的子串
int flag=0;//在源串中找到目的子串为1，未找到为0
char * targetAddress;//目标子串在源串中第一次出现啊的位置
char * sourcePoint,* targetPoint;//sourcePoint源串工作指针，targetPoint目标子串工作指针
char * start;//每一次字符串匹配在source开始的位置，第一次比较在source串的第一个字符
char * end;//指向在source串中能完成最后一次匹配target的地址
end=&source[strlen(source)-strlen(target)];
for(start=source;start<=end;start++){
sourcePoint=start;//工作指针初始化
targetPoint=target;
while(*sourcePoint++==*targetPoint++){
if(*targetPoint=='\0'){//表明匹配成功
flag=1;
break;
}
}
if(flag){//找到目标子字符串
targetAddress=start;
break;
}
}
if(flag){
return targetAddress;
}else{
return NULL;
}
}
8.编写一个函数，其功能是使输入字符串反序，在一个使用循环语句为这个函数提供输入的完整程序中进行测试。
#include <stdio.h>
#include <string.h>
#define MAX 80
char * stringReverse(char * input,char * reserve);
int main(void) {
char input[MAX];//存放要被逆序的字符串
char result[MAX];//存放字符串逆序后的结果
while(1){
printf("请输入待逆序的字符串，输入quit结束程序:");
gets(input);
while(input[0]=='\0'){//未输入任何字符 {
printf("您未输入任何内容，请重新输入，输入quit结束程序:");
gets(input);
}
if(strcmp(input,"quit")==0)
break;//输入quit结束程序
stringReverse(input,result);//将输入程序逆序
printf("逆序后的字符串为:%s\n",result);
}
printf("程序结束!");
return 0;
}
char * stringReverse(char * input,char * reserve){//input表源字符串，reserve表逆序字符串
int len=strlen(input);
int i,j;//i循环计数器,j逆序操作下标
for(i=0,j=len-1;i<len;i++,j--){
reserve[i]=input[j];
}
reserve[i]='\0';
return reserve;
}
9.编写一个函数。其参数为一个字符串，函数删除了字符串中空格。在一个可以循环读取的程序中测试，知道用户输入空行。对于任何输入字符串，该函数都应该适用并可以显示结果。
#include <stdio.h>
#include <string.h>
#define MAX 80
char * deleteSpace(char * input ,char * result);
int main(void){
char input[MAX];//存储输入字符串
char result[MAX];//保存去掉空格后的字符串
while(1){
printf("请输入要处理的字符串，直接输入回车结束程序：");
gets(input);
if(input[0]=='\0')
break;//直接输入回车程序结束
deleteSpace(input,result);
printf("处理后的字符串为：");
puts(result);
}
puts("程序结束!");
return 0;
}
char * deleteSpace(char * input ,char * result){
int i;//保存input字符串的下标变量
int j;//保存result字符串的下标变量
int len=strlen(input);
for(i=0,j=0;i<len;i++){
if(input[i]!=' ' && input[i]!='\t'){
result[j++]=input[i];
}
}
result[j]='\0';//j总是保存下一个可以填入字符的位置下标 ，在字符结尾处填入空字符表结束
return result;
}
10.编写一个程序，读取输入，直到读入了10个字符串或遇到EOF，由二者中最先被满足的那个终止读取过程。这个程序为用户提供一个5个选项的菜单：输出初始字符串列表、按ASCII顺序输出字符串、按长度递增顺序输出字符串、按字符串中第一个单词的长度输出字符串和退出。菜单可以循环，直到用户输入退出请求。当然，程序要能真正完成菜单中的各项功能。
#include <stdio.h>
#include <string.h>
#define ROWS 10
#define COLS 80
int getInput(char strings[ROWS][COLS]);
void printString(int num,char *point[ROWS]);
void sortByAscii(int num,char * point[ROWS]);
void sortByLength(int num,char * point[ROWS]);
void sortByFirstWordLen(int num,char * point[ROWS]);
char getChoice();
void initialize(int num,char inputs[ROWS][COLS],char * point[ROWS]);
int main(void){
char inputs[ROWS][COLS];//存放输入的10个字符串
char * point[ROWS];//用于排序的工作指针
int count;//成功读入字符串个数
int i;//i循环计数器
char choice;//菜单选择项
//获得字符串列表的输入
puts("请输入最多10个字符串，以EOF符结束输入:");
count=getInput(inputs);
do{
choice=getChoice();
switch(choice){
case '1'://输出字符串初始化列表
initialize(count,inputs,point);
puts("输出初始化列表:");
printString(count,point);
break;
case '2':
initialize(count,inputs,point);
sortByAscii(count,point);
puts("按ASCII排序输出:");
printString(count,point);
break;
case '3':
initialize(count,inputs,point);
sortByLength(count,point);
puts("按字符串长度顺序输出:");
printString(count,point);
break;
case '4':
initialize(count,inputs,point);
sortByFirstWordLen(count,point);
puts("按字符串首单词长度输出:");
printString(count,point);
break;
case '5':
break;
}
}while(choice!='5');
puts("程序结束!");
return 0;
}
//获得字符串输入函数，通过getchar()函数实现，返回成功读入的字符串个数
int getInput(char strings[ROWS][COLS]){
int i=0;//外层循环计数器
int j;//内层循环计数器
int ch;//接收每一次getchar()函数输入
int flag=0;//flag等于1表示读入EOF字符，否则等于0
while(i<ROWS && !flag){//输入的字符串数没有达到10个且到目前为止没有读到过EOF字符，否则终止输入
j=0;//每进行一次外层循环则表示要读入一个新的字符串，所有j要赋值为0
while((ch=getchar())!='\n' && ch!=EOF && j<COLS-1){//内层while循环结束表示读入完一个字符串或者读入了EOF,j<COLS-1表明需要给空字符预留位置
if(j==0 && (ch=='\t' || ch==' '))//去掉第一个有效字符之前的空格或制表符
continue;
strings[i][j]=ch;
j++;
}
if(ch==EOF){//用户输入了EOF，结束输入
break;
}
if(j==0){//用户直接输入了回车s，提示重新输入
printf("您未输入任何内容，请重新输入：");
continue;
}
strings[i][j]='\0';
i++;
}
return i;
}
//输出初始化字符串列表
void printString(int num,char *point[ROWS]){
int i;
for(i=0;i<num;i++){
puts(point[i]);
}
}
//根据ASCII码的升序输出各字符串，通过选择排序实现
void sortByAscii(int num,char * point[ROWS]){//num是字符串的数量 ，字符指针数组，与字符串数量相同，用于排序输出
int i,j;//外、内层循环计数器
char * temp;
for(i=0;i<num-1;i++){//对num个字符串排序，只需要n-1次遍历查找当前未排序字符串中最小字符串，因最后一次排序可确定两个字符串的位置
for(j=i+1;j<num;j++){//point[i]总保存当前已比较过的字符串中最下的
//开始比较
if(strcmp(point[i],point[j])==1){//point[i]的ascii码要大于string[j]，需要更新point[i]地址
temp=point[i];//保证最后一次排序不会覆盖地址
point[i]=point[j];
point[j]=temp;
}
}
}
}
//按各输入字符串的长度递增输出字符串
void sortByLength(int num,char * point[ROWS]){
int i,j;//循环计数
char * temp;
for(i=0;i<num-1;i++){//外层循环循环一次找到未排序字符串中长度最小的一个字符串
for(j=i+1;j<num;j++){//遍历所有未排序字符串找到长度最小的字符串的地址与point[i]交换s
if(strlen(point[i])>strlen(point[j])){
temp=point[i];
point[i]=point[j];
point[j]=temp;
}
}
}
}
//按字符串中第一个单词的长度递增输出各字符串，利用strchr()函数实现
void sortByFirstWordLen(int num,char * point[ROWS]){
int i,j,min,index;
int stringlen[ROWS];//保存各字符串第一个单词长度的数组
char *temp;
for(i=0;i<num;i++){//求待排序的所有字符串的长度，保存在stringlen[ROWS]数组中
if(strchr(point[i],' ')==NULL && strchr(point[i],'\t')==NULL){//如果该字符串没有空格或制表符，意味着是一个单词
stringlen[i]=strlen(point[i]);
continue;
}
else if(strchr(point[i],' ')!=NULL && strchr(point[i],'\t')==NULL){//字符串中只有空格分割符
stringlen[i]=strchr(point[i],' ')-point[i];
}else if(strchr(point[i],' ')==NULL && strchr(point[i],'\t')!=NULL){//字符串中只有制表分割符
stringlen[i]=strchr(point[i],'\t')-point[i];
}else{//字符串中既有空格分割符又有制表分割符
if(strchr(point[i],' ')>strchr(point[i],'\t')){//取两种分割符靠前的位置
stringlen[i]=strchr(point[i],'\t')-point[i];
}else{
stringlen[i]=strchr(point[i],' ')-point[i];
}
}
}
for(i=0;i<num-1;i++){
min=stringlen[i];
for(j=i+1;j<num;j++){
if(min>stringlen[j]){
min=stringlen[j];//将长度做交换
stringlen[j]=stringlen[i];
stringlen[i]=min;
temp=point[i];//将对应的指针做交换
point[i]=point[j];
point[j]=temp;
}
}
}
}
//获得用户输入的选项
char getChoice(){
char ch;
puts("1.输出字符串列表.");
puts("2.按ASCII码升序输出字符串列表.");
puts("3.按字符串长度升序输出字符串列表.");
puts("4.按字符串首单词长度升序输出字符串列表.");
puts("5.退出.");
printf("请选择:");
do{
ch=getchar();
if(ch=='\n'){
printf("您未输入任何内容，请重新输入:");
continue;
}
else if(ch>'5' || ch<'1'){
printf("您输入的内容不合法，请重新输入:");
while(getchar()!='\n')//处理无效输入字符
continue;
}
else
{
while(getchar()!='\n')//处理无效输入字符
continue;
break;
}
}while(1);
return ch;
}
//初始化工作指针数组char * point[ROWS]
void initialize(int num,char inputs[ROWS][COLS],char * point[ROWS]){
int i;
for(i=0;i<num;i++){
point[i]=inputs[i];
}
}
11.编写一个程序。功能是读取输入，直到遇到EOF，并报告单词书、大写字母数、小写字母数、标点符号数、数字字符数。使用ctype.h系列的函数。
#include <stdio.h>
#include <string.h>
#include <ctype.h>
#define MAX 150
int getWordsNum(char * inputStr);
void getUpperLowerCharNum(char * inputStr,int * up,int * low,int * digit,int * punct);
int main(void){
int i;//循环计数器
int up=0,low=0,digit=0,punct=0; //统计大写字母数，小写字母数，数字字符数，标度符号数
char input[MAX];
for(i=0;i<MAX;i++)
input[i]='\0';
printf("请输入字符串:\n");
for(i=0;i<MAX-1;i++){
if((input[i]=getchar())==EOF){
break;
}
}
input[i]='\0';
getUpperLowerCharNum(input,&up,&low,&digit,&punct);
printf("单词的个数为:%d,大写字母数为:%d,小写字母数为:%d,数字字符数为:%d,标点符号数:%d\n",getWordsNum(input),up,low,digit,punct);
printf("程序结束!\n");
return 0;
}
//统计单词数；任意两个不连续空字符之前连续的字母字符或数字所组成的字符串为一个单词
int getWordsNum(char * inputStr){
int i;
int count=0;//记录单词个数
for(i=0;inputStr[i]!='\0';){
if(isalnum(inputStr[i])){//如果找到了字母字符，则单词数加1，并且通过内层循环达到该单词之后第一个非字母字符
count++;
while(isalnum(inputStr[++i]) && inputStr[i]!='\0'){//让i递增直到这个单词的结尾之后的第一个空字符或达到输入末尾
}
}else{
i++;
}
}
return count;
}
//统计大写字母和小写字母
void getUpperLowerCharNum(char * inputStr,int * up,int * low,int * digit,int * punct){//up大写字母数变量，low小写字母数变量,digital数字字符数变量,punc标点符号数变量
char * p;//工作指针
for(p=inputStr;*p!='\0';p++){
if(*p>='A' && *p<='Z'){
(*up)++;
}
else if(*p>='a' && *p<='z'){
(*low)++;
}
else if(ispunct(*p)){
(*punct)++;
}
else if(isdigit(*p)){
(*digit)++;
}
else
;
}
}
12.编写一个程序，按照相反的单词顺序显示命令行参数。即，如果命令行参数是see you later，程序的显示应该是 later see you。
#include <stdio.h>
int main(int argc,char *argv[]){
int i;
//逆序输出参数
for(i=argc-1;i>0;i--){
printf("%s ",argv[i]);
}
printf("\n程序结束!");
return 0;
}
13.编写一个计算乘幂的基于命令行的程序。第一个命令行参数为double类型数，作为幂的底数；第二个参数为整数，作为幂的指数。
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
int main(int argc,char * argv[]){
double buttom;//底数
int index;//指数
char * end;//指向数字结尾的非数字字符
if(argc<3){
printf("你输入的参数个数不正确，程序结束!");
return 0;
}
buttom=strtod(argv[1],&end);//获得double型底数
if(argv[1]==end){
printf("您输入了不正确的底数，程序结束!");
return 0;
}
index=strtol(argv[2],&end,10);//获得double型指数
if(argv[2]==end){
printf("您输入了不正确的指数，程序结束!");
return 0;
}
printf("pow(buttom,index)=%f",pow(buttom,index));
return 0;
}
14.使用字符分类函数实现atoi()函数。
#include <stdio.h>
#include <ctype.h>
int myatoi(char * numStr);
int main(void){
printf("myatoi(\"\\n123\\n\")=%d\n",myatoi("\n123\n"));
printf("myatoi(\"\\n\t 321 4\")=%d\n",myatoi("\n\t321 4"));
printf("myatoi(\"\\n\t 321\t4\")=%d\n",myatoi("\n\t321\t4"));
printf("myatoi(\"\\n\t 123a\")=%d\n",myatoi("\n\t 123a"));
printf("myatoi(\"\\n\t a123 \t\")=%d\n",myatoi("\n\t a123 \t"));
return 0;
}
//实现atoi()函数， 无法完成转化返回0
int myatoi(char * numStr){
int i;//循环计数器
int result=0;//转换后的最终结果
int flag=0;//该变量控制当遇到空字符所做的处理：在还未读入一个非空字符的情况下，flag置0表示跳过空格继续看下一个字符，当flag置1时表示当前已读入非空字符,单再读入空字符时结束转换
for(i=0;numStr[i]!='\0';i++){
if(isspace(numStr[i])){//是空字符就跳过，继续检查下一个字符
if(flag==0)
continue;
else
break;//flag置1时表示当前已读入非空字符,单再读入空字符时结束转换
}
if(numStr[i]<='0' || numStr[i]>='9'){//一旦读入非数字字符则结束转换，不管该非数字字符是首个读入的非空字符还是数字结尾字符
break;
}
switch(numStr[i]){//开始转换
case '0':result=result*10+0;break;
case '1':result=result*10+1;break;
case '2':result=result*10+2;break;
case '3':result=result*10+3;break;
case '4':result=result*10+4;break;
case '5':result=result*10+5;break;
case '6':result=result*10+6;break;
case '7':result=result*10+7;break;
case '8':result=result*10+8;break;
case '9':result=result*10+9;break;
}
flag=1;
}
return result;
}
15.编写一个程序，其功能是读取输入，直到遇到文件结尾，把文件显示出来。要求程序可以识别并执行下面命令含参数：
-p:按原样输出 -u:将输入全部转换为大写 -l:将输入全部转换为小写
#include <stdio.h>
#include <string.h>
#include <ctype.h>
#define MAX 150
int main(int argc,char *argv[]){
int i=0;
char * index;
char instr[MAX];
if(argc<2){
printf("您没有输入参数，程序执行失败!");
return 0;
}
if(strcmp(argv[1],"-p")!=0 && strcmp(argv[1],"-u")!=0 && strcmp(argv[1],"-l")!=0){
printf("您输入的参数有误，程序执行失败!");
return 0;
}
puts("请输入您要转换的内容:");
while((instr[i]=getchar())!=EOF && i<MAX-1){
i++;
}
instr[i]='\0';
puts("按您的选择输出如下：");
if(strcmp(argv[1],"-p")==0){
index=instr;
while(*index!='\0'){
putchar(*index);
index++;
}
}else if(strcmp(argv[1],"-u")==0){
index=instr;
while(*index!='\0'){
putchar(toupper(*index));
index++;
}
}else{
index=instr;
while(*index!='\0'){
putchar(tolower(*index));
index++;
}
}
return 0;
}
382
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
