指针与字符串学习

指针应用场景二

函数返回多个值，某些值就只能通过指针返回。

传入的参数实际上是需要保存带回的结果的变量。

const修饰的数据类型是指常类型，常类型的变量或对象的值是不能被更新的。
const关键字的作用主要有以下几点：
（1）可以定义const常量，具有不可变性。 例如：  const int Max=100; int Array[Max];  
（2）便于进行类型检查，使编译器对处理内容有更多了解，消除了一些隐患。例如： void f(const int i) { .........} 编译器就会知道i是一个常量，不允许修改； 
 （3）可以避免意义模糊的数字出现，同样可以很方便地进行参数的调整和修改。 
（4）可以保护被修饰的东西，防止意外的修改，增强程序的健壮性。 还是上面的例子，如果在函数体内修改了i，编译器就会报错； 例如：  void f(const int i) { i=10;//error! }  
（5） 为函数重载提供了一个参考。  class A { ......  void f(int i) {......} //一个函数  void f(int i) const {......} //上一个函数的重载 ......  };  
（6） 可以节省空间，避免不必要的内存分配。 例如：  #define PI 3.14159 //常量宏  const doulbe Pi=3.14159; //此时并未将Pi放入ROM中 ......  double i=Pi; //此时为Pi分配内存，以后不再分配！  double I=PI; //编译期间进行宏替换，分配内存  double j=Pi; //没有内存分配  double J=PI; //再进行宏替换，又一次分配内存！  const定义常量从汇编的角度来看，只是给出了对应的内存地址，而不是象#define一样给出的是立即数，所以，const定义的常量在程序运行过程中只有一份拷贝，而#define定义的常量在内存中有若干个拷贝。
  （7） 提高了效率。 编译器通常不为普通const常量分配存储空间，而是将它们保存在符号表中，这使得它成为一个编译期间的常量，没有了存储与读内存的操作，使得它的效率也很高。

动态内存分配malloc与free

1.有借有还。

2.向malloc申请的空间大小是以字节为单位的。

3.返回类型是void*，需要类型转换为自己需要的类型。

(int*)malloc(n*sizeof(int))

4.free只能还申请来的空间首地址

处理字符串的函数

#include<string.h>

strlen

strcmp

strcpy

strcat

strchr

strstr

strlen函数

#include<stdio.h>
#include<string.h>
size_t mylen(const char *s)
{
int cnt=0;
while(s[cnt]!='\0'){
cnt++;
}
return cnt;
}
int main (int argc,char const *argv[])
{
char line[]="hello";
printf("strlen=%lu\n",mylen(line));
printf("sizeof=%lu\n",sizeof(line));
return 0;
}

strcmp函数

#include<stdio.h>
#include<string.h>
int mycmp(const char*s1,const char*s2)
{
int idx=0;
while(s1[idx]==s2[idx]&&s1[idx]!='\0')
{
idx++;
}
return s1[idx]-s2[idx];
}
int mycmp(const char*s1,const char*s2)//指针版本 
{
while(*s1==*s2 && *s1!='\0')
{
s1++;
s2++;
}
return *s1-*s2;
}


int main (int argc,char const *argv[])
{
char s1[]="abc ";
char s2[]="abc";
printf("%d\n",strcmp(s1,s2)); //一个空格为ACELL码为32 S1>s2 strcmp返回值为1 
printf("%d\n",mycmp(s1,s2));
printf("%d\n",'a'-'A');
return 0;
}

strcpy函数

#include<stdio.h>
#include<string.h>
char* mycpy(char*dst,const char*src)
{
int idx=0;
while(src[idx]){
dst[idx] = src[idx];
idx++;
}
dst[idx]='\0';
return dst;
}
char* mycpy1(char*dst,const char*src)//指针版本 
{
char* ret =dst;
int idx=0;
while(*src!='\0'){
*dst++=*src++;
//*dst=*src;
//dst++;
//src++;

}
return ret;
dst[idx]='\0';
return ret;
}


int main (int argc,char const *argv[])
{
char s1[]="abc ";
char s2[]="abc";
printf("%d\n",strcmp(s1,s2)); //一个空格为ACELL码为32 S1>s2 strcmp返回值为1 
printf("%d\n",mycmp(s1,s2));
printf("%d\n",'a'-'A');
return 0;
}

strchr函数

#include<stdio.h>
#include<string.h>
#include<stdlib.h>
int main(int argc, char const *argv[])
{
char s[]="hello";
char *p = strchr(s,'l');
char *t=(char*)malloc(strlen(p)+1);
strcpy(t,p);
printf("%s\n",t);
free(t);
return 0;
}
找到l后面的字符


#include<stdio.h>
#include<string.h>
#include<stdlib.h>
int main(int argc, char const *argv[])
{
char s[]="hello";
char *p = strchr(s,'l');
char c =*p;
*p='\0';
char *t=(char*)malloc(strlen(s)+1);
strcpy(t,s);
printf("%s\n",t);
free(t);
return 0;
}

找到L前面的字符 小技巧