C语言复习

1.进制

三要素：数位（第几位） 基数 位权（当前位对应的值）

二进制：B     八进制：O   十进制：D   十六进制：X

0和1                  111 /072               10              1111 1111/0xFF

正数的原码=反码=补码

负数的反码=原码取反  补码=反码+1

无符号整数补码举例：

假设使用8位表示无符号整数，计算无符号整数5的补码。

1. 确定位数：n=8n=8。

2. 计算补码：

   28−5=256−5=25128−5=256−5=251

3. 二进制表示：

   • 5的二进制：00000101

   • 251的二进制：11111011

左移<<    低位补0，不需要考虑补码

右移>>  无符号数：高位补0   负数需要知道其补码表示

               有符号数：高位补符号位（正补0，负补1）负数需要知道其补码表示

负数需要补码参与运算

2.     ASCII 码   0~127

 NULL   \0   的ASCII码都是0

\n的ASCII码是10

A的ASCII码是65     a的ASCII码是97

0  '0' 的ASCII码是48

回车的ASCII码是13

3.关键字

3.1存储类型：auto static extern  register

面试题：static关键字的特点

       1.作用域：static修饰的变量或者函数只能在本文件使用，不能被外部文件引用。

        2.生命周期延长：局部变量：生命周期从函数调用开始到程序结束

                                   全局变量：生命周期从程序运行到程序结束

        3.存储位置：静态区

        4.初始化：static修饰的变量未赋初始值，自动初始化为0，只初始化一次

面试题：如何引用一个其他文件的全局变量    

        头文件 extern int a;//声明

        .c文件  int a=10;//定义

        其他文件之间调用a变量

3.2  数据类型

        char,short,int,float,double,long,signed,unsigned,

注意：short和long不能搭配，互斥

        取值范围：一个字节占8bit

char    -2^7~2^7-1

int    -2^31~2^31-1

unsigned char: 0~2^8-1   0~255

3.3 构造数据类型

struct   union   enum

大小：struct   最大成员类型的整数倍

           union    最大成员的大小

例题：

union {
    int x;
    char a;
} u;

u.x = 10;
printf("%c\n", u.a);

x和a共用一块内存   x占4字节   a占其中低地址1字节

10的二进制为00000000 00000000 00000000 00001010

因此a的ASCII码为10   对应字符\n

3.4控制语句：

if,else,for,while,do..while,break,continue,return

3.5  其他

sizeof,strlen,constmvolatile,typedef,void

面试题:sizeof和strlen的区别

sizeof用来计算数组，结构体等的大小，包含\0

strlen用来计算字符串的长度，不包含\0

面试题：const的特点

const修饰的变量不能修改，常量化

const修饰的变量必须初始化

C++中const修饰的函数为常成员函数，保护成员不被修改

C++中形参const修饰用于保护成员不被修改

C++中const修饰对象表示常对象，只能访问常成员函数

int const  *a   指向可以变，指向的内容不可以变

const int  * a   指向可以变，指向的内容不可以变

int  *const a     指向不能变，指向的内容可以变

const int *const a   指向不可以变，指向的内容不可以变

面试题：typedef和define的区别

typedef是重定义，可以将复杂的名字简单化

define是宏定义关键字，用于宏替换，通常表达式需要加（）

4.标识符

命名规则：由字母数字下划线组成，不能以数字开头，不能和关键字重复

5.运算符：

1.关系

2.算数

3.位

笔试题：将一个数的某一位置1或清零，写出表达式.

数a     需要设置的位置n

置1        a =  a |    (1<<n)

置0        a =  a  &  (~（1<<n）)

4.逻辑

5.三目

6.赋值

7.逗号

8.自增自减

6.输入输出语句

1.scanf("%d",&a)     printf("%d",a)

2.int a;a = getchar()        char b;   putchar(b)    while(getchar()!=10);吸收回车,读取直到碰到回车，输入缓冲区全部丢弃

3.gets(name)        puts(name)    

7.for循环笔试题

笔试题：打印水仙花数100~999

int a,b,c;
for(int i=100;i<1000;i++)
{
        a=i%10;
        b=i/10%10;
        c=i/100;
        if((int)(pow(a,3)+pow(b,3)+pow(c,3))==i)//if(a*a*a+b*b*b+c*c*c==i)
        {
                printf("%d是水仙花数\n",i);
        }
}

笔试题：打印99乘法表

for(int i=1;i<10;i++)
{
        for(int j=1;j<=i;j++)
        {
                printf("%d * %d = %-2d ",i,j,i*j);
        }
        printf("\n");
}

笔试题：打印图案

*
**
***
****
*****

for(int i=1;i<6;i++)
{
        for(int j=1;j<=i;j++)
        {
                printf("*”);
        }
        printf("\n");
}

8.while循环

while(!E);     !E等价于 E==0

9.数组

什么是一维数组：相同数据类型元素的集合

什么是二维数组：数组的数组，每个元素是一维数组    行可以省略   列不能省略

内存连续存储

10.排序算法

1.冒泡排序:两两比较，满足条件交互

int temp;
for(int i=1;i<length;i++)
{
        for(int j=0;j<length-i;j++)
        {
                if(arr[j]<arr[j+1})
                {
                        temp=arr[j];
                        arr[j]=arr[j+1];
                        arr[j+1]=temp;
                }
        }
}

2.选择排序:每次从未排序的部分与已排序的最后一个比较，选择最大或者最小元素,返回下标，放在已排序的后面

for(int i=0;i<length-1;i++)//已排序
{
        int index=i;
        int temp;
        for(int j=i+1;j<length;j++)//未排序
        {
                 if(arr[j]<arr[index])
                    {index=j;}
        }
       if(index!=i)
        {
                temp = arr[index];
                arr[index]=arr[i];
                arr[i] =temp;
        }
}

笔试题：打印斐波那契数列前15个数

int arr[15]={1,1};
for(int i=2;i<15;i++)
{
        arr[i]=arr[i-1]+arr[i-2];
}
for(int i=0;i<15;i++)
{
        printf("%d ",arr[i]);
}
printf("\n");

笔试题：杨辉三角前十行

int arr[10][10];
for(int i=0;i<10;i++)
{
    arr[i][0]=1;
    arr[i][i]=1;
    for(int j=1;j<i;j++)
    {
        arr[i][j]=arr[i-1][j]+arr[i-1][j-1];
    }
}

for(int i=0;i<10;i++)
{
    for(int j=0;j<=i;j++)
    {
        printf(" %d ",arr[i][j]);
        if(i==j)
        {
            printf("\n");
        }    
    }
}

11.数组清零函数

1.bzero(buff,sizeof(buff))

2.memset(buff,0,sizeof(buff))

12.指针

面试题：说一说对指针的理解

指针分为一级指针，二级指针，多级指针，常用的是一级指针和二级指针。

一级指针就是指向变量的指针，存放变量的地址。二级指针就是指向一级指针的指针，存放一级指针的地址。

指针不初始化就是野指针，对野指针进行访问或者操作会出现段错误。

对指针进行解引用获取指针存放地址对应的值

面试题：指针和数组的区别

指针指向的内存地址可以是不连续的，数组的内存地址是连续的。

指针需要动态分配内存，数组内存是静态分配的。

指针分配的空间需要手动释放，数组的内存系统会自动释放。

指针取值需要解引用，数组取值用数组名[index]

指针的大小是4或者8字节，数组大小由数据类型和元素个数决定。

指针数组：int *p[3]={&a,&b,&c}   

数组指针：int (*p)[3]=arr  arr为数组

面试题：指针数组和数组指针的区别

指针数组本质上是一个数组  *p[3], 数组中每个元素都是指针

数组指针本质上是指针，（*p)[3]，（）可以理解为强调它是指针，指向一维数组时，（*p）[0]代表第一个元素的值，指向二维数组时，p[0][0]代表第一个元素的值.

13.函数

值传递：void fun(int a,int b)      fun(a,b)  a,b不会改变

地址传递   void fun(int *a,int *b)       fun(&a,&b)  a,b会改变

引用传递      void fun(int &a,int &b)      fun(a,b) a,b会改变

14.string函数族

写出strlen、strcpy、strcat源码实现

int strlen(const char* buff)
{
        int count=0;
        while(*buff)
        {
            count++;
            buff++;
        }
        return count;
}

char* strcpy(char* str,const char* buff)
{
       if (str == NULL || buff == NULL)// 检查空指针
       { 
            return;
       }
       char *temp=str;
       while(*buff)
       {
            *str=*buff;
            str++;
            buff++;
       }
       *str='\0';
       return temp;
}

char *strcat(char* str,const char* buff)
{
       if (str == NULL || buff == NULL)// 检查空指针
       { 
            return;
       }
       
       while(*str)
       {
            str++;
       }
       while(*buff)
       {
            *str=*buff;
            str++;
            buff++;
       }
       *str='\0';
       return temp;
}