基础十

原创

茗君（Major_S） 2021-08-02 14:24:20 ©著作权

文章标签 #include 字符串字符数组指针数组数组 文章分类 C/C++ 后端开发

©著作权归作者所有：来自51CTO博客作者茗君（Major_S）的原创作品，请联系作者获取转载授权，否则将追究法律责任

1.review
2.从字符串常量到字符数组
3.原生字符串处理strcatstrlen
4.原生字符串处理strcpy
5.原生字符串处理strcmp
6.多文件编程xx.h与xx.c
7.字符指针数组入门
8.指针数组应用和那些零

1.review

//常量字符串，双引号引起的一串字符，自动追加了‘\0’//32-127 NULL
//大小存储进程空间的data rodata
//语言如何处理常量字符串,将其编译为一个指向rodata 一串字符的首地址。
//这个首地址能，代表字符串吗? 数组三要素
//首地址 + 步长 + 范围(自动追加了’\0’)

// 通过字符指针的方式，可以查看常量字符串，但是不可以修改。
// 修改里面的内容，要通过字符数组 char arr[]
//字符数组和字符串这间的相同性质。并不代表字符串可以与任意的字符数组之间划等号
//等价条件：sizeof(字符数组)的大小>=sizeof(字符串)的大小
//sizeof(字符数组)的大小< sizeof(字符串)的大小此时不存在等价关系字符数组，此时只是字符数组而己

2.从字符串常量到字符数组

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

//常量字符串，双引号引起的一串字符，自动追加了‘\0’//32-127      NULL
//大小   存储   进程空间的data rodata
//语言如何处理常量字符串,将其编译为一个指向rodata     一串字符的首地址。
//这个首地址能，代表字符串吗?   数组三要素
//首地址   +    步长   +    范围(自动追加了'\0')


// 通过字符指针的方式，可以查看常量字符串，但是不可以修改。
// 修改里面的内容，要通过字符数组  char arr[]
//字符数组和字符串这间的相同性质。并不代表字符串可以与任意的字符数组之间划等号
//等价条件：sizeof(字符数组)的大小>=sizeof(字符串)的大小
//sizeof(字符数组)的大小< sizeof(字符串)的大小此时不存在等价关系字符数组，此时只是字符数组而己
int main()
{


    char arr[6] ="major";
    arr[1] = 'i';
    printf("%s",arr);

    return 0;
}

基础十_数组

综上所述，对于一个字符串的处理，就变成了，对字符指针，或是对字符数组的处理。

3.原生字符串处理strcat、strlen

求字符串的长度

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


//传数组的时候，要传三要素，即数组名和范围
//传字符串的时候，此时只需要传p或是arr因为字符串自带结束标志

//标准库是不作入参性检查的


int myStrlen(char *str)
{
    
    //if(str == NULL) //入参性检查
    //    exit(1);
    int len;
    for (len=0;*str++;len++) ;
    return len;
}
int main()
{

    char *p = "major";  // 将指针赋给了p
    char arr[] = "major";  // 将指针指向的内容赋给了arr


    char *q = p;
    int count =0;
   // while(*q != '\0')
   // {
   //     count++;
   //     q++
   // }
    while(*q++)
    {
        count++;
    }

    // for(count=0;*q++;count++);
    printf("count = %d\n",count);


    int len = strlen(arr);
    printf("len = %d\n",len);

    int mylen = myStrlen(arr);
    printf("mylen = %d\n",mylen);

    return 0;
}

基础十_字符数组_02

链接两个字符串

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

//被链接的串，必须要有足够的空间。

int main()
{

    char firstName[30] = "shen_";
    char lastName[30] = "major";

    strcat(firstName,lastName);

    printf("%s\n",firstName);
    return 0;
}

基础十_字符数组_03

基础十_字符数组_04

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

int main()
{

    char firstName[30] = "shen_";
    char lastName[30] = "major";

    //strcat(firstName,lastName);

    char *p ,*q;
    p = firstName;
    q = lastName;
    while (*p) p++;
    
    while (1) {
        *p=*q;
        if(*p =='\0'){
            break;
        }
        p++;
        q++;
    }

  //  while (*p=*q) {
  //      p++;
  //      q++;
  // }
    
   // while (*p++ = *q++);
    printf("%s\n",firstName);

    




    return 0;
}

//返回char*是为了实现链式表达

char *myStrcat(char *dest,char *src)
{
   char *d = dest;
   while(*dest) dest++; // 先到尾部
   while(*dest++ = *src++); // 开始拼接
   return d;
}

4.原生字符串处理strcpy

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

int main()
{
    char name[200];
    char *pName ="she";
    char name2[200] = "maj";

    name[0] = name2[0];
    name[1] = name2[1];
    name[2] = name2[2];
    name[3] = name2[3];

    printf("name = %s\n",name);

    name[0] = pName[0];
    name[1] = pName[1];
    name[2] = pName[2];
    name[3] = pName[3];

    printf("name = %s\n",name);


    return 0;
}

基础十_#include_05

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


//strcpy被拷贝的区域,必须有足够的空间容纳。

//先拷贝，再判断，再++

char * myStrcpy(char *dest,char *src)
{
    char *d = dest;
    while(*dest++ = *src++);
    return d; // 链式法则
}

int main()
{
    char name[200];
    char *pName ="she";
    char name2[200] = "maj";

    //strcpy(name,pName);
    myStrcpy(name,pName);
    printf("name = %s\n",name);

    //strcpy(name,name2);
    myStrcpy(name,name2);
    printf("name = %s\n",name);


    return 0;
}

基础十_指针数组_06

5.原生字符串处理strcmp

int myStrcmp(char *s1,char *s2)
{
      for(;*s1&&*s2 && *s1 ==*s2;s1++,s2++);
      return *s1 - *s2;
}

6.多文件编程xx.h与xx.c

注重实现方法论

mystring.h

#ifndef __MYSTRING_H__
#define __MYSTRING_H__


int myStrlen(char *str);
char *myStrcat(char *dest,char *src);
char * myStrcpy(char *dest,char *src);
int myStrcmp(char *s1,char *s2);

#endif

mystring.c

#include  "mystring.h"

int myStrlen(char *str)
{

    //if(str == NULL) //入参性检查
    //    exit(1);
    int len;
    for (len=0;*str++;len++) ;
    return len;
}
char *myStrcat(char *dest,char *src)
{
   char *d = dest;
   while(*dest) dest++; // 先到尾部
   while(*dest++ = *src++); // 开始拼接
   return d;
}
char * myStrcpy(char *dest,char *src)
{
    char *d = dest;
    while(*dest++ = *src++);
    return d; // 链式法则
}

int myStrcmp(char *s1,char *s2)
{
      for(;*s1&&*s2 && *s1 ==*s2;s1++,s2++);
      return *s1 - *s2;
}

main.c

#include <stdio.h>
#include "mystring.h"

//1.把一类功能的函数写到一个xxx.c里面
//2.把xxx.c中所有的函数声明写到xxx.h中去
//3.在xxx.h中加入，避免头文件重复包含的语句
//4.将xxx.h包含到xxx.c中去自包含,自实现的用“”include
//5,在main函数中包含xxx.h    谁用谁包含


int main()
{
    char *s1 = "major";char *s2="major";
    int ret =myStrcmp(s1,s2);
    if(ret ==0)
        printf("==");
    return 0;
}

基础十_#include_07

注解

1.实现
2.声明
3.把1(实现)作成库（ibmystr.so）给别人提供mystring.h就可以了

7.字符指针数组入门

指针数组

一个数组中的各个元素都是字符指针，我们称该数组为字符指针数组，或是指针数组。
比如: char *name[]就是一个指针数组。

#include <stdio.h>
#include "mystring.h"


//指针数组的本质是数组，数组指针的本质是指针


int main()
{
    int arr[] = {1,2,3,4}; //整型数组
    char cArr[] = {'a','b','c','d'}; // 字符数组
    
    char a,b,c,d;
    char * cpArr[] = {&a,&b,&c,&d}; // {char*,char*,char*,char*} 字符指针数组

    int aa,bb,cc,dd;
    int * ipArr[] = {&aa,&bb,&cc,&dd}; // {int*,int*,int*,int*} 整型指针数组
    
    return 0;
}

基础十_指针数组_08

#include <stdio.h>
#include "mystring.h"
//指针数组的本质是数组，数组指针的本质是指针
int main()
{


    char *pArr[] = {"major1","major2","major3","major4"};
    for (int i=0;i<4;i++) {
        printf("%p  %s\n",pArr[i],pArr[i]);
    }

    return 0;
}

排序

#include <stdio.h>
#include "string.h"


//指针数组的本质是数组，数组指针的本质是指针


int main()
{


    char *pArr[] = {"major2","major3","major1","major4"};
    for (int i=0;i<4;i++) {
        printf("%p  %s\n",pArr[i],pArr[i]);
    }

    printf("\n");

    int n = sizeof (pArr)/sizeof (*pArr);
    char *pt;
    for (int i =0;i<n-1;i++) {
        for (int j=i+1;j<n;j++) {
            if(strcmp(pArr[i],pArr[j])>0)
            {
                pt = pArr[i];
                pArr[i] = pArr[j];
                pArr[j] = pt;
            }
        }
    }

    for (int i=0;i<4;i++) {
        printf("%p  %s\n",pArr[i],pArr[i]);
    }


    return 0;
}

基础十_#include_09

基础十_数组_10

8.指针数组应用和那些零

#include <stdio.h>
#include "string.h"



int main()
{

    char *cArr[] = {"major","major","major"};
    printf("sizeof(cArr) = %d\n",sizeof (cArr));


    return 0;
}

基础十_字符串_11

基础十_字符串_12

#include <stdio.h>
#include "string.h"


//在启动进程，通过命令行，传递给进程的参数，即传递main的参数

// arg argument参数  c count个数的意思argc参数的个数的意思
// argv arg    指针数组v vector指针数组向量

int main(int argc, char * argv[])
{

    for (int i=0;i<argc;i++) {
        printf("argv[%d] = %s\n",i,argv[i]);
    }

    return 0;
}

基础十_字符数组_13
基础十_字符串_14

#include <stdio.h>
#include "string.h"


//在启动进程，通过命令行，传递给进程的参数，即传递main的参数

// arg argument参数  c count个数的意思argc参数的个数的意思
// argv arg    指针数组v vector指针数组向量

int main(int argc, char * argv[])
{

    for (int i=0;i<argc;i++) {
        printf("argv[%d] = %s\n",i,argv[i]);
    }

    return 0;
}

基础十_指针数组_15
基础十_#include_16
基础十_#include_17

零

零所代表的意义

基础十_字符数组_18

#include <stdio.h>
#include "string.h"


int main(int argc, char * argv[])
{


    printf("int %d\n",0);
    printf("float %d\n",0.0);
    printf("'0'= %d\ %c\n",'0','0');
    printf("NULL = %p NULL = %d\n",NULL,NULL);
    printf("\\0 = %d  \\0=%C\n",'\0','\0');
    return 0;
}

基础十_数组_19