Linux 操作系统和C语言（详解）

概念：在程序运行过程中其值不会发生变化的量

分类：

1、字符型常量

标识： '    '

一般用char类型的变量来存储字符型常量

'A'   'Z'   '\\'   ‘\'    '\0'

' ！'

转义字符： ‘\041’   ‘\x21'

2、字符串常量

标识： ""

"hello" "a" "0"

字符串都以'\0'作为结束标志

一般用char类型的数组来存储字符串常量

char ch[10] = "hello";

3、整型常量与强制类型转换

整型常量：

整数 0 100 1000

一般用short、int、long、long int、long long类型的变量来存储整型常量

浮点型常量

小数 0.0 3.1415926

一般用float、double类型的变量来存储浮点型常量

4、指数常量

3*10^8 => 3E+8

2*10^-5 => 2E-5

一般用double类型的变量来存储指数型常量

5、标识常量

宏定义：起标识作用

#define 宏名 常量或表达式

#define PI 3.1415926

特点：先替换再计算

例：

#define N 2

#define M N+3

#define NUM N+M/2+1

int main()

{

printf("NUM = %d\n",NUM); // 6 5 6.5 5.5

return 0;

}

6、冒泡排序

将5 4 3 2 1从小到大排序

原数列

5 4 3 2 1

第一轮：

4 5 3 2 1

4 3 5 2 1

4 3 2 5 1

4 3 2 1 5

第二轮：

3 4 2 1 5

3 2 4 1 5

3 2 1 4 5

第三轮：

2 3 1 4 5

2 1 3 4 5

第四轮：

1 2 3 4 5

总结：

N个数 比较N-1轮

每轮比较次数从N-1递减

实现：

for循环嵌套实现，外层循环控制比较轮数，内层循环控制比较次数。

核心代码：

N个数从大到小排序：

for(i=0;i<N-1;i++)

{

for(j=0;j<N-1-i;j++)

{

if(num[j]<num[j+1])

{

tmp = num[j];

num[j] = num[j+1];

num[j+1] = tmp;

}

}

}

7、选择排序

从小到大排序

红色箭头i：锁定位置 从第一个走到倒数第二个数

蓝色箭头j：寻找最值 从箭头i指向的数据后开始一直走到最后一个数据

绿色箭头k：暂时标记 如果箭头j找到更小的就把k叫过去进行标记

排序思路：

先让i锁定一个位置，让k记录i的位置，然后j从i的下一个数据开始找较小的数，当找到之后，让k临时标记，j继续查找更小的，直达走到最后一个数据，j任务完成。

只需要将i标记的位置和k标记的位置数据进行交换，即可将最小的数放到前面。

算法实现：

N个数从小到大排序：

for(i=0;i<N-1;i++)

{

k=i;

for(j=i+1;j<N;j++)

{

if(num[j]<num[k])

{

k=j;

}

}

if(i!=k)

{

tmp=num[i];

num[i]=num[k];

num[k]=tmp;

}

}

代码实现：

8、二维数组

概念：有行有列数组

定义格式：

[存储类型] [数据类型] 二维数组名[行数][列数];

（auto） int num[2][3];

元素个数： 行数 * 列数

初始化：

1.全部初始化

int num[2][3] = {1,2,3,4,5,6};

int num[2][3] = {{1,2,3},{4,5,6}};

初始化后：

| 1 2 3 |

| 4 5 6 |

2.部分初始化

int num[2][3] = {1,2};

初始化后：

| 1 2 0 |

| 0 0 0 |

int num[2][3] = {{1},{2}};

初始化后：

| 1 0 0 |

| 2 0 0 |

3.未初始化

int num[2][3]; （局部）

//未初始化均为随机值

数组大小：

行数 * 列数 * 数据类型大小

int num[2][3]; //24字节 = 2 * 3 * 4

数组输入输出：

int num[2][3] = {0};

输入：

for(i=0;i<3;i++)

{

scanf("%d",&num[0][i]);

}

for(i=0;i<3;i++)

{

scanf("%d",&num[1][i]);

}

用循环嵌套思想优化：

for(i=0;i<2;i++)

{

for(j=0;j<3;j++)

{

scanf("%d",&num[i][j]);

}

}

输出：

for(i=0;i<2;i++)

{

for(j=0;j<3;j++)

{

printf("%d ",num[i][j]);

}

putchar(10);

}

练习：定义一个三行四列的数组，从终端录入数据，找出其最大值、最小值，并输出其下标。

例如：

max ： num[1][2] = 99

min : num[0][2] = 1

练习：有一个三行三列的矩阵，如下：

| 1 2 3 |

| 4 5 6 |

| 7 8 9 |

求出其非对角线上的元素值的和。

练习：从终端录入小张、小王、小刘三位同学C语言、C++、数据结构三门课的成绩，

求出各科平均分以及三位同学的平均成绩。

9、字符数组

概念：用于存储字符串的数组称为字符数组。

char s[10] = {"hello"};

char s[10] = {'a','b','c'};

char s[10] = "hello";

char s[ ] = "hello"; //6字节

//字符串的结束标志为'\0'

char s1[3] = {"abc"}; //不合法

char s2[3] = {'a','b','c'}; //合法

//如果以字符串的形式输出，以上两种写法都没有结束标志。

字符数组输入：

1）以字符为单位输入

char str[10] = {0},i;

for(i=0;i<5;i++)

{

scanf("%c",&str[i]);

}

//输入字符个数由循环次数决定，输入不够灵活。

2）以字符串的形式输入

scanf("%s",str);

//空格无法输入

解决方案：

利用scanf("%[^\n]",str); 可以读取一行字符串，直到遇到换行符\n结束

%[]的格式控制法：%[scanfset]

以^字符开头的scanfset，表示在读入字符串时将匹配所有不在scanfset中出现的字符，遇到scanfset中的字符输入就结束。

3）字符串输入函数

char *gets(char *s);

功能：从终端获取一串字符

参数：char *s 目标字符数组的首地址

返回值：同参数

//注：gets函数不检查数组大小，容易造成越界赋值导致的栈溢出问题，因此编译时会 有危险警告。

后续可使用fgets录入字符串。

字符数组输出：

1）以字符为单位输出

char str[10] = "hello";

for(i=0;i<5;i++)

{

printf("%c",str[i]);

}

2）以字符串的形式输出

printf("%s\n",str);

//以‘\0’作为输出结束标志

3）字符串输出函数

int puts(const char *s);

功能：向终端输出一串字符

参数：const char *s 要输出的字符串的首地址

返回值：执行成功 - 非负数

今日作业：

1）打印杨辉三角的前十五行 （已知第一列为1）

1

1 1

1 2 1

1 3 3 1

1 4 6 4 1

....

#include <stdio.h>
int main(int argc, const char *argv[])
{
int a[15][15]={{0}};
int i,j;
for(i=0;i<15;i++)
{
a[i][0]=1;
for(j=1;j<=i;j++)
a[i][j]=a[i-1][j-1]+a[i-1][j];
for(i=0;i<15;i++){
for(j=0; j<=i;j++)
printf("%8d",a[i][j]);
printf("\n");
}
return 0;

2）从终端录入一串字符串，统计其中数字字符的个数，将其中数字字符求和输出。

#include <stdio.h>
int main(int argc, const char *argv[]){
char s[100];
int i=0;
int j=0;
int sum=0 ;
gets(s);
/ /puts(s);
while(s[i]!='\0'){
if('0'<=s[i]&&s[i]<='9'){
j++;
sum+=(s[i]-'0');
i++ ;
}
printf("字符串中数字字符的个数为: %d\n", j);
printf("字符串中数字字符求和为: %d\n"，sum);
return 0;

10、string家族函数

    #include <string.h>
    strlen
    函数原型：size_t strlen(const char *s);
    功能：计算字符串的实际长度 （截止到‘\0’）
    参数：const char *s 字符串的首地址
    返回值：size_t 字符串实际长度
    
    面试题：strlen和sizeof的区别？
    答：strlen是个函数，计算的字符串的实际长度(截止到‘\0’)。
        而sizeof是个关键字，计算的是变量或者类型占用的内存的大小。    
        char str[10] = "hello";
        sizeof(str) = 10;
        strlen(str) = 5;
    
    练习：仿写strlen功能。
        从终端任意输入一串字符，输出其实际长度。
    
    strcpy
    char *strcpy(char *dest, const char *src);
    功能：实现字符串复制 （包含'\0'）
    参数：char *dest   目标字符串地址
          const char *src 源字符串地址
    返回值: dest 目标字符串地址
    char *strncpy(char *dest, const char *src, size_t n)
    //按照指定的字符个数实现字符串复制
    思考题：char s1[32] = "hello",如何将“world”存储到s1中？
        s1 = "world" ;  //错误，因为s1是个地址常量，常量不能被赋值。
        s1[0] = 'w';
        s1[1] = 'o';
        ...        
        //可以，但没必要
        用strcpy来实现：
        strcpy(s1,"world");
        
    strcat
    char *strcat(char *dest, const char *src);
    功能：实现字符串拼接 （包含'\0'）
    参数：char *dest   目标字符串地址
          const char *src 源字符串地址
    返回值: dest 目标字符串地址    
    char *strncat(char *dest, const char *src, size_t n)
    //按照指定字符个数进行拼接
    
    strcmp
    int strcmp(const char *s1, const char *s2);
    功能：比较首个不相同的字符的ascii（包含'\0'）
    参数：要比较的两个字符串的首地址
    返回值：  s1 > s2   1
              s1 = s2   0
              s1 < s2   -1
    int strncmp(const char *s1, const char *s2, size_t n);
    //按照指定字符个数进行比较

（八）指针

1、概念

      地址：内存中每个字节都有一个编号，这个编号就是地址（一般用十六进制表示）
      指针：指针就是地址，地址是个常量。
      指针变量：用于存放指针（地址）的变量称为指针变量 

2、定义格式

      [存储类型]  [数据类型]   *指针变量名;
        （auto）     int         *p;
       // 在定义指针，*起标识作用。
       //定义指针时，数据类型表示的指向的地址存储的数据类型。

3、指针的运算

      1）赋值运算
         a.指针指向普通变量
           int num = 10;
           1 - int *p = &num;  //指针p指向了num这个整型变量。
           2 - int *p = NULL;
               p = &num;
         b.指针指向一维数组
           int num[5] = {1,2,3,4,5};
           1 - int *p = num;     //数组名就代表数组首个元素的地址
           2 - int *p = &num[0]; //指针p指向了数组首地址
           p <=> num
           访问元素num[i]的值：
              通过数组名直接访问：  num[i]  *(num+i)
              通过指针名间接访问：  p[i]    *(p+i)
           访问元素num[i]的地址：
              通过数组名直接访问：  &num[i]   num+i
              通过指针名间接访问：     &p[i]      p+i     
           
           推导过程： 指针p指向数组num，p里面保存了num数组的首地址，即p指向数组首个元素的地址。
                      p => &num[0]  那p+i则为num[i]的地址 &num[i]
                     *(p+i)相当于对&num[i]进行取值运算，因此*(p+i) => num[i]                      
              
            约定地址的等级高于元素值的等级
           
            升级 : 加&   去掉[]            
            降级 ：加*   添加[]
              
         c.指针指向另一个指针指向的数据        
           int num;
           int *p = &num;
           int *q = p;
          
      2）取值取址运算
         &  取地址符 ：取变量的地址
         *  取值符   ：取地址上的值
         &和*互为逆运算，可以抵消。    
            *&num = num
    
      3）算术运算
        p+1 ：向高地址方向移动一个数据的大小
        p-1    ：向低地址方向移动一个数据的大小    
        //以上两种运算，p的指向不变
        p++、p--才会真正改变指针指向
        
      4）关系运算
         >   <   >=  <=  ==  !=
         指针之间的关系运算比较的地址的高低，
         指向高地址的指针大于指向低地址的指针。
         指向不同区域、不同类型的指针都没有关系运算意义。

4、指针大小

      在32位操作系统中，指针的大小恒为4字节。
      指针的有效寻址空间就是4G。
      寻址范围：0 ~ 2^32-1     
      4,294,967,296字节 = 4,194,304KB = 4096MB = 4GB
      int num；
      int *p1 = &num; 
      char ch;
      char *p2 = &ch;
      double f;
      double *p3 = &f;

       sizeof(p1) sizeof(p2)  sizeof(p3)
         
      练习：1.终端录入一串字符串，将其中字符a替换成字符*输出
              （用指针实现）         
            2.通过指针实现字符串倒置
               字符从终端输入
               输入 hello
               输出 olleh
               
        段错误Segmentation fault (core dumped)
        原因:1）内存访问越界
             2）使用了野指针
                野指针：没有明确的指向对象
                定义指针时如果没有明确指向则初始化为空，防止出现野指针问题。

5、指针的修饰（const、void）

      const 常量化
        作用：只读修饰
        1）const修饰普通变量
         #include<stdio.h>
         int main(int argc, const char *argv[])
         {
             const int num = 10;
             //num = 20;   // error: 只读变量num无法被赋值
      
             int *p = &num;
             *p = 20;  
             printf("%d\n",num);
             return 0;
         }
        
        2）const修饰指针
           int num1 = 10,num2 = 20;
           const int *p  = &num1;
           //int const *p = &num1;
           *p = 20;  //错误，const修饰*p整体，无法通过更改*p来更改指针指向的地址上的值
           p = &num2; //可行，指针指向可变。
        
           int num1 = 10,num2 = 20;
           int * const p  = &num1;
           *p = 20;  //可行，*p可更改。
           p = &num2; //错误，因为const修饰p，则指针指向不可更改。   
             
       void    空类型
          void *p = NULL; //空类型指针指向数据类型是不确定的。
          //空类型指针可以指向任何一种类型的变量。
          int a = 10;
          char b = '!';
          float c = 3.14;
          void *p = NULL;
          //空类型指针在使用时需要针对指向的数据类型进行强制类型转换。
          p = &a;
          printf("%d\n",*(int *)p);  
          p = &b;
          printf("%c\n",*(char *)p);
          p = &c;
          printf("%f\n",*(float *)p);
          

6、二级指针

    概念：指向一级指针的指针称为二级指针
    示例：
        int num = 10;
        int *p = &num;
        int **q = &p;  //二级指针q指向了一级指针p
        
        访问num的值：
           num   *p    **q
        访问num的地址
           &num   p     *q        

7、指针与数组

    直接访问：通过数组名进行访问
    间接访问：通过指向数组的指针进行访问

    1.指针与一维数组
      int num[5]  = {1,2,3,4,5};
      int *p = num;
      访问num[i]的值：
      直接访问： num[i]   *(num+i)
      间接访问： p[i]     *(p+i)
      访问num[i]的地址：
      直接访问： &num[i]   num+i
      间接访问： &p[i]     p+i    
      
      printf("%p\n",num+1);  //打印num[0]的地址
      printf("%p\n",p+1);    //打印num[0]的地址，指针指向不变。    
      
      printf("%p\n",num++);  //报错，num是数组首地址是个地址常量，常量不能自加。
      printf("%p\n",p++);    //打印num[0]的地址，再让指针向后移动。     
    
      注意：
        1）*和++都是单目运算符，优先级相同。
        2）单目运算符结合性是从右向左。
        
      *p++  ：先取出p的值参与取值（*）运算，再让指针向高地址方向移动一个数据。
      *(p++)：先取出p的值参与取值（*）运算，再让指针向高地址方向移动一个数据。
      
      *++p  ：先让指针向高地址方向移动一个数据，再对p的值进行取值运算。
      *(++p)：先让指针向高地址方向移动一个数据，再对p的值进行取值运算。
      
      ++*p  ：先对p进行取值运算，再对p指向的地址上的值进行自加运算。
      ++(*p)：先对p进行取值运算，再对p指向的地址上的值进行自加运算。
      
      (*p)++：先对p进行取值运算，参与完其他运算之后，再对指针指向的地址上值进行自加运算。
      
    2.指针与二维数组      
      int num[2][3];
      int *p = num;   //错误，因为二维数组的数组名是个二级地址，因此不能用一级指针直接指向。
      推导过程：
       num =>  &num[0]  =>  &&num[0][0]
       
      访问num[i][j]的元素值：
         num[i][j]   *(num[i]+j)   *(*(num+i)+j)
      访问num[i][j]的元素地址：
         &num[i][j]   num[i]+j      *(num+i)+j       

8、数组内存移动问题

    一维数组：
        &num       整个数组
        num  &num[0]   元素        
        
        int num[5];
        &num +1     20字节  
        num +1       4字节
        &num[0] +1   4字节     
     
    二维数组：    
        &num                整个数组
        num    &num[0]       行地址
        num[0] +1            列地址
        &num[i][j]          元素地址        
        
        int num[2][3];
        &num +1                 24字节
        num+1     &num[0]+1     12字节
        num[0]+1  &num[0][0]+1   4字节

9、数组指针

    概念：本质上是个二级指针，专用于指向数组（二维）的指针称为数组指针。
    定义格式：     
        [存储类型]   [数据类型]    (*数组指针名)[列数];
          （auto）       int        (*p)[i];  
        //数组指针在定义时，[]填的指向的二维数组的列数。
    示例：  
        int num[2][3];
        int (*p)[3] = num;
        
        p    行地址
        *p   列地址   元素地址
        **p  元素值        
      
        数组指针p指向了二维数组num，因此num和p等价，此时p代表的是num数组的行地址。
        访问num[i][j]的值：
        直接访问：  num[i][j]   *(num[i]+j)   *(*(num+i)+j)
        间接访问：  p[i][j]     *(p[i]+j)     *(*(p+i)+j)  
        
        访问num[i][j]的地址
        直接访问： &num[i][j]   num[i]+j      *(num+i)+j     
        间接访问： &p[i][j]       p[i]+j      *(p+i)+j

10、指针数组
       

    概念：本质上是个数组，用于存放指针（地址）的数组称为指针数组    
    定义格式：
          [存储类型]   [数据类型]   *指针数组名[大小];    
            （auto）      int         *num[i]; 
          大小：元素个数
    应用示例：
        1.指针数组存储普通变量的地址    
          int a = 10,b = 20,c = 30;
          int *p[3] = {&a,&b,&c};
          通过数组名p访问b的值：
              *p[1]     *(*(p+1))
          通过数组名p访问b的地址：
               p[1]      *(p+1)
               
        2.指针数组存储二维数组的每行首个元素的地址（列地址）       
          int  num[2][3];
          int *p[2] = {num[0],num[1]};       
            int *p[2] = {&num[0][0],&num[1][0]};
          推导过程：
          p  =>  &p[0]  =>  &num[0]  =>  num
          因此p和num等价
          
          通过数组名p访问二维数组中元素num[i][j]的值：
              p[i][j]         *(p[i]+j)       *(*(p+i)+j)
          
          通过数组名p访问二维数组中元素num[i][j]的地址：
              &p[i][j]          p[i]+j          *(p+i)+j
        
        3.指针数组存储字符串
          char *p[3] = {"hqyj","helloworld","23032!!!"};
          
          打印字符串"helloworld"
          printf("%s\n",p[1]);
          printf("%s\n",*(p+1));
          
          打印字符串“hellowolrd”中的字符‘w’
          printf("%c",p[1][5]);
          printf("%c",*(p[1]+5));
          printf("%c",*(*(p+1)+5));
        
        4.命令行传参
        argv就是一个指针数组，里面存放的是命令行传递的字符串。
        argc表示argv指针数组内存储数据的个数，即命令行传递字符串的个数。
        int main(int argc, const char *argv[])
        {
            printf("ip:%s\n",argv[1]);
            return 0;                           
        } 
        
    数组大小：
        元素个数  *  4（指针大小）
        //因为32位操作系统中指针的大小恒为4字节