C基础(36——40)

//两个指针
#include <stdio.h>
#include <stdlib.h>

char* Reverse(char * s)
{
                 char* left=s ;
                 char* right=s ;

                 while(*right)
                                right++;
                right--;

                 while(right>left)
                {
                                 //swap—>创建临时变量
                                 /*char tmp=*left;
                                *left=*right;
                                *right=tmp;*/

                                 //swap—>异或
                                *left=*left^*right;
                                *right=*left^*right;
                                *left=*left^*right;

                                left++;
                                right--;
                }

                 return s ;
}
void test()
{
                 char str[]="hello,world-coming!" ;  //注意此处不能用char* str="hello,world-coming!",因为指针存于常量区,不能去改变它

                printf( "%s\n",Reverse(str));
}
int main()
{
                test();
                system( "pause");
                 return 0;
}

////递归
//#include <stdio.h>
//#include <stdlib.h>
//#include <string.h>
//
//void Reverse(char* str,int left,int right)
//{
//             if(left>=right)
//                             return;
//
//             char tmp=str[left];
//             str[left]=str[right];
//             str[right]=tmp;
//
//             Reverse(str,left+1,right-1);
//}
//void test()
//{
//             char str[]="hello,world-coming!";
//             int len=strlen(str)-1;
//
//             Reverse(str,0,len);
//
//             printf("%s\n",str);
//}
//int main()
//{
//             test();
//             system("pause");
//             return 0;
//}

////数组
//#include <stdio.h>
//#include <stdlib.h>
//#include <string.h>
//
//char* Reverse(char* str,int left,int right)
//{
//             while(left<right)
//             {
//                             char tmp=str[left];
//                             str[left]=str[right];
//                             str[right]=tmp;
//
//                             left++;
//                             right--;
//             }
//
//             return str;
//}
//void test()
//{
//             char str[]="hello,world-coming!";
//             int len=strlen(str);
//
//             printf("%s\n",Reverse(str,0,sizeof(str)/sizeof(str[0])-2));  //sizeof(str)/sizeof(str[0])是算上‘\0‘的
//}
//int main()
//{
//             test();
//             system("pause");
//             return 0;
//}

结果:

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

int SubStr(char dst[],char src[],int start,int len)
{
                 char* first=src +start;
                 char* end=src +start+len;
                 int i=0;

                 while(*first && first<end /*&& i<len*/ )
                {
                                 dst[i]=src [start+i];
                                first++;
                                i++;
                }

                 dst[i]=‘\0‘ ;  //切记

                 return i+1;  //包括‘\0‘
}

//变量较少的实现方法
//int SubStr(char dst[],char src[],int start,int len)
//{
//             int i=0;
//             
//             while(len-- && src[start]!=‘\0‘)
//                             dst[i++]=src[start++];
//
//             dst[i]=‘\0‘;
//
//             return i+1;
//}
void test()
{
                 char str[]="hello world" ;
                 char target[100];

                printf( "%d\n",SubStr(target,str,4,20));
                printf( "%s\n",target);
}
int main()
{
                test();
                system( "pause");
                 return 0;
}

结果:

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

void test()
{
                 int c;
                 while((c=getchar())!=‘\n‘ )
                {
                                 if(c>=‘A‘ && c<=‘Z‘)
                                                c+=32;

                                putchar(c);
                }
                printf( "\n");
}
int main()
{
                test();
                system( "pause");
                 return 0;
}

结果:

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

void test()
{
                 int c;
                 while((c=getchar())!=EOF )
                {
                                 if(c>=‘A‘ && c<=‘z‘)
                                                c= ‘A‘+‘z‘ -c;

                                putchar(c);
                }
}
int main()
{
                test();
                system( "pause");
                 return 0;
}

结果:

#include <stdio.h>
#include <stdlib.h>
#include <assert.h>

//把dst当成一个指针
//char* Strcpy(char* dst,const char* src)
//{
//             assert(src);
//             int i=0;
//
//             while(*src)
//             {
//                             dst[i++]=*src++;
//             }
//
//             dst[i]=‘\0‘;
//
//             return dst;
//}
//把dst当指针
char* Strcpy(char * dst,const char* src)
{
                assert(src);
                assert(dst);
                 char* d=dst;

                 while(*src)
                                *d++=*src++;

                *d= ‘\0‘;

                 return dst;
}
//库函数的实现方法
//char* Strcpy(char* dst,const char* src)
//{
//             assert(src);
//             assert(dst);
//             char* d=dst;  //先保存住dst的首地址,让d移动
//
//             while((*d++=*src++)!=‘\0‘)
//                             ;
//
//             return dst;
//}
void test()
{
                 char* str="hello world,change the WORLD" ;
                 char dest[100];

                printf( "%s\n",Strcpy(dest,str));
}
int main()
{
                test();
                system( "pause");
                 return 0;
}

结果:

时间: 2024-10-06 08:30:00

C基础(36——40)的相关文章

javaweb基础(36)_jdbc进行批处理

在实际的项目开发中,有时候需要向数据库发送一批SQL语句执行,这时应避免向数据库一条条的发送执行,而应采用JDBC的批处理机制,以提升执行效率. JDBC实现批处理有两种方式:statement和preparedstatement 一.使用Statement完成批处理 1.使用Statement对象添加要批量执行SQL语句,如下: 1 Statement.addBatch(sql1); 2 Statement.addBatch(sql2); 3 Statement.addBatch(sql3);

编写高质量代码:改善Java程序的151个建议(第3章:类、对象及方法___建议36~40)

建议36:使用构造代码块精简程序 什么叫做代码块(Code Block)?用大括号把多行代码封装在一起,形成一个独立的数据体,实现特定算法的代码集合即为代码块,一般来说代码快不能单独运行的,必须要有运行主体.在Java中一共有四种类型的代码块: 普通代码块:就是在方法后面使用"{}"括起来的代码片段,它不能单独运行,必须通过方法名调用执行: 静态代码块:在类中使用static修饰,并用"{}"括起来的代码片段,用于静态变量初始化或对象创建前的环境初始化. 同步代码块

Java基础(36):String与基本数据类型之间的双向转换

Java 中基本类型和字符串之间的转换 在程序开发中,我们经常需要在基本数据类型和字符串之间进行转换. 其中,基本类型转换为字符串有三种方法: 1. 使用包装类的 toString() 方法 2. 使用String类的 valueOf() 方法 3. 用一个空字符串加上基本类型,得到的就是基本类型数据对应的字符串 再来看,将字符串转换成基本类型有两种方法: 1. 调用包装类的 parseXxx 静态方法 2. 调用包装类的 valueOf() 方法转换为基本类型的包装类,会自动拆箱 PS:其他基

ospf 的基础配置

R1 R2 R3属于OSPF 的骨干区域,R1 R2 R3位于10.1.1.0/24 网段 R2 R3 R4 位于OSPF 的40.1.1.0/24 网段. 希望R2 作为 10.1.1.0 网段的DR, R3作为BDR;R3 作为40.1.1.0 网段的DR,R2 作为BDR. 基础配置: R1 配置: R1(config)#line console 0 R1(config-line)#exec-timeout 0 0 R1(config-line)#logging synchronous R

java ------ IO(从基础到加强)

IO基础到加强 基础篇 一.一些基础知识概念 1.文件的逻辑结构 流式文件 记录式文件 2.文件的存取方法 顺序存取 随机存取 3.文件的使用 操作接口 应用程序接口 4.流的定义和作用 流的定义.方向性和读/写操作 流采用缓冲区技术 流的作用:简单的说就是控制文件的输入和输出 5.流的存在 通过这个图,就可以很好的理解输入流和输出流,它们的命名是以程序为参展点,写进程序来,就是要用输入流,写出程序(写到文件中)就是要用输出流. 二.输入.输出流 主要分为两大类:字节流和字符流 1.字节流 (1

AxureRP8实战手册(基础31-40)

AxureRP8实战手册(基础31-40) 本文目录 基础31.     切换元件库 第2章          页面设置 基础32.     设置页面居中 基础33.     设置页面背景(图片/颜色) 基础34.     设置页面颜色(草图/黑白) 第3章          设置条件 基础35.     添加条件判断 基础36.     设置条件限制 基础37.     用例条件转换 第4章          使用变量/公式 基础38.     全局变量设置 基础39.     局部变量设置

UI设计师零基础入门到精通精品视频教程【155课高清完整版】

[福吧资源网分享]课程是非常完整的,也是非常零基础的,适合任何学员,有需要的可以下载看看!课程目录:第1章 Adobe Photoshop CS6课时1 Adobe Photoshop CS6入门基础 52:24课时2 创建与编辑选区(上) 46:57课时3 创建与编辑选区(下) 48:59课时4 掌握图层与图层组(上) 48:01课时5 掌握图层与图层组(下) 57:35课时6 绘制位图图像(上) 47:46课时7 绘制位图图像(下) 46:37课时8 绘制矢量图形(上) 46:49课时9 绘

一: DRF web应用框架基础

---恢复内容开始--- 一: web 应用模式(有两种) 1: 前后端不分离(前端从后端直接获取数据) 2: 前后端分离 二: api 接口 原因一: 为了在团队内部形成共识.防止个人习惯差异引起的混乱,我们需要找到一种大家都觉得很好的接口实现规范,而且这种规范能够让后端写的接口,用途一目了然,减少双方之间的合作成本. 目前市面上大部分公司开发人员使用的接口服务架构主要有:restful.rpc. 1: rpc: 翻译成中文:远程过程调用[远程服务调用]. post请求 action=get_

计算机科学基础知识(二)Relocatable Object File

一.前言 一个合格的c程序员(也可以叫做软件工程师,这样看起来更高大上,当然,我老婆心情不好的时候总是叫我"死打字的",基本也能描述这份职业,呵呵)需要理解编译.链接和加载的过程,而不是仅仅关注c语言的语法和词法.本文主要以此为切入点,描述linux系统下,一个普通的hello world程序的生命历程,并借机灌输一些程序编译时和运行时的基本术语和概念.当然,由于我本人是一个linuxer,因此借用linux来描述这些知识会方便些,但是对于计算机科学而言,这些东西概念上是类似的,只是实