嵌入式基础学习|C语言篇——指针（含进阶）二

指针 操作字符一维数组 
 字符型的一维数组 
   字符串 
   字符数组的形式  --- 栈上的数据  可读可写 
   字符串常量区    --- 常量区的数据，只能读，不能改 
int puts(const char *s)
const char * p   //const -- 限定为只读 
                 //const 离谁近，就限定谁  (就近原则)   
const char *p //const 此时是限定基类型的 --表示将基类型限定为只读 
              //准确说，是限定了通过 *p 的方式 访问到的基类型为只读
char const * p //const 限定的是基类型 
char * const p //限定p为只读，表示不能修改p中值
               //不能修改p的指向    
const char * const p = &a;  // p不能被修改 *p不能被修改 
const int a=10; //a限定为只读
int puts(const char *s)  //*s 
{
}

const char *p = "hello"; //"hello" 字符串常量 
*p = 'H';   //提前发现问题 

设计函数的形参时，能写成const的就写成const
可以提高参数的适用性 

puts(str); //char str[10]
puts(p);  //char *
puts(p);  // const char *
size_t Strlen(const char *s) //size_t 本质是 long int
{
    统计长度 
}

char *Strcpy(char *dest, const char *src)
{
    char *ret = dest; 

    拷贝
    return ret;
}
返回值 返回的是 dest 目标字符串的首地址  --- 支持链式操作 

char * Strncpy(char *dest, const char *src, size_t n)
{ 
    //'\0'  n也在控制拷贝过程 
}
n表示:
    将src中的前n个字符拷贝到dest中 
    
    src长度 > n  将前n个字符拷贝 dest中，但是不会以'\0'结尾 
    src长度 < n  将字符串拷贝完成后，看n是否结束 ，如果没有，需要继续拷贝
                  后面直接拷贝 '\0' 
    始终 保证 拷贝 n 次 
int a,b,c;
a = b = c = 1;  

char *Strcat(char *dest, const char *src)
{   
     //1.定位到dest的'\0'
     //2.拷贝 
     //3.dest 中最后 '\0'
}

char *Strncat(char *dest, const char *src, size_t n)
n 表示 将 src中的前n个字符拼接到dest中 
n  最后 加上 '\0'
   
   n < 字符串len   将前n个字符 拼接到dest中 最后 '\0'
   n > 字符串长度  将src中的字符串 拼接过去即可 
   
strcmp 
   int Strcmp(const char *s1, const char *s2)
   {
   }

   int Strncmp(const char *s1, const char *s2, size_t n);
   n 表示 ，将 s1 和 s2 中前n个字符比较 
 作业:
  编写程序实现单词的倒置
  "how are you" -> "you are how"
  "uoy era woh"
  //"you are how"
  //思维 --- 问题解决掉?
          p 
  uoy era woh'\0'

  起始位置 
  找到结束位置 
  逆序单词 

   "how"
   "are" 
   "you"
内存模型 --- 大端 / 小端 

快速排序 

指针基础
1.指针概念 
2.指针变量定义 
3.被调修改主调 
--------------
指针进阶 
4.指针操作整型一维数组
  整型 
  字符型 
 数组传参 --- 并没有 把数组中的所有数据 赋值给被调函数
              为了效率，只需要将数组首元素的地址传过去 
              *(p+i) //指针运算 
              实现了被调函数中可以获得主调函数中数组的数据 

算法:
  1.最大值 
  2.逆序 
  3.排序 
 字符型一维数组 
 字符串 
 
 const char * const  p //
  (1)          (2)
  *p                p //p中的数据不能修改 
 
 //指针常量 
 //常量指针 
 
 函数:
  strlen
  strcpy/strncpy 
  strcat/strncat
  strcmp/strncmp 
 
指针 + 二维数组 
整型二维数组 
   1.数组 
     特点 
       连续性 
       单一性
       有序性 
   2.二维数组 
    二维数组的 本质 --- 一维数组的数组
                        C语言中只有一维数组 
                        区别在于，数组元素的类型 
                        int 
                        int[4] 
   3.指针的运算
     p+1 
     p>q
     
     int a[3][4]; //二维数组 
     int[4] a[3]; //理解角度 ---本质 
     
     a[0] //首元素 -- a[0]代表一整行 --数据类型 int[4]
    &a[0] //首元素地址 
          //地址类型 -- int[4] --     
          //取了一块存放着 int[4]这种类型的数据的 空间的地址 
          
          int[4] *p =  //数组指针 --- 指向的数据类型 是一个 数组类型 
          
   int a; //
   &a //int * --- 取了一块存放着int型数据的空间的地址 
   int *p = &a;
   
   a[i][j] <=> *(*(p+i)+j)<=> *(*(a+i)+j)

//这个数组中存放的是 地址数据 ，字符串在 常量区对应空间的地址数据     
const char * s[5] = {"hello","world","china","english","america"}; 
char s[5][10] = {"hello","world","china","english","america"};
const char * s[5] = {"hello","world","china","english","america"}; 
首元素:
   &s[0]  // const char *  * p
            ----基类型---   
const char* *p ;//定义时 有两个星号 -- 二级指针 
基类型       
二级指针:
    如果 要指向的空间 本身存放的数据类型 就是指针类型的数据 

日历:
1.getMonthDays
2.getAllDays
3.getWeekDays
4.printCal
作业:
  编写一个程序实现功能：
  将字符串”Computer Science”赋给一个字符数组，
  然后从第一个字母开始间隔的输出该字符串，用指针完成。
  Cmue cec
------------------------------------------------------
1.指针基础 
2.指针 + 一维数组 
3.指针 + 二维数组 
4.指针 + 指针数组 
  char * s[] = {"hello","world","china"};
5.指针 + 指针 
  二级指针 
  多级指针 
6.指针 + 函数 
 int add(int a,int b)
 {
   return a + b;
 }
 int main()
 {
    printf("add = %d\n",add(1,2));
    return 0;
 }

 函数名 --- 函数的入口地址 
 函数名 --- 标识符 
 函数名 --- 代表的数据类型？
           int (int a,int b) //函数类型 
                             //表示是这么一类函数
                             //返回值类型为int型，带有两个int型形参的这么一类函数    
 int(int a,int b) * p; //理解角度 没有问题 

 int (*p)(int a,int b) // C语言正确的语法形式    
                       // 函数(的)指针
用途:
  是通过 指针的方式，实现函数的调用 
注意:
  函数指针中，不需要做 * 运算，因为没用 
callback (回调) 
S

------------------------------------------------------------
1. 练习:
    写一个程序 实现加，减，乘，除
    以回调函数的形式，打印对应的结果 
    void processData(int a,int b, int (*pfunc)(int,int))
    {
        printf("result = %d\n",);
    }

int(*pfunc[4])(int,int)  //是一个数组 
                         //存放函数指针的数组 
                         //是带了一个int型返回值 和 两个int型形参的这样的函数的指针                  
void qsort(   void *base,  //接收数组首地址
            size_t nmemb,  //要排序的数组元素个数 
            size_t size,   //单个元素的大小 
            int (*compar)(const void *, const void *) //指向一个比较规则的 函数
          );

int cmpFunc(const void *a, const void *b)  //a 和 b 获得到是 要比较的数组中的两个元素的地址 
{
   
}
void *    //是一个指针 --- 指向的是 void类型 
          //void叫空类型 
          //万能指针  --- 可以接收任意类型的地址 
          //如果通过 void *类型变量 做间接运算时，需要转化成具体的类型 
int main(int argc,char *argv[])
{
}
argc   // --- 命令行参数的个数  
argv   // --- 命令行参数对应字符串的数组 
char *s[] = {"hello","world","china"};

指针函数：
char * strcpy(char *dest, const char *src); //返回值类型 为 指针类型的函数 

指针函数  函数指针 
指针数组  数组指针
char *s[10];
int a[3][4];

int(*p) [4]; //数组指针

指针:
1.概念
2.被调修改主调 
---------------
进阶：
指针 + 一维数组 
---------------
高阶:
指针 + 二维数组 
指针 + 指针 
指针 + 函数