码迷,mamicode.com
首页 > 编程语言 > 详细

C语言基础补充

时间:2018-10-22 20:17:55      阅读:186      评论:0      收藏:0      [点我收藏+]

标签:null   har   情况   分析   最大值   手动   主函数   字符   针对   

编译器四个步骤

  1. 预处理:头文件展开和宏定义展开条件编译

    gcc -E hello.c -o hello.i

  2. 编译:语法检查,生成汇编代码

    gcc -S hello.i -o hello.s

  3. 汇编:声明目标代码,无法执行,因为缺少链接

    gcc -c hello.s -o hello.o

  4. 链接:链接动态库,比如windows中的dll文件

    gcc hello.o -o a.out

为什么要声明变量

提前说明占用多大空间。

原码 补码 反码

原码和普通数字的区别:负数最高位是1,其余7位保持等价。(共八位)
反码和原码的区别:负数最高位不变,其余为取反。
补码和反码的区别:补码=反码+1

补码的意义:符合位和其他位可以等同运算,如果最高位产生进位,则可以舍弃

补码求原码:(下面的步骤仅对于负数,正数不变)

  1. 最高位不变,其他位取反
  2. 在1的基础上加1
    例如:
    char a = 0x81;
    printf("%d\n", a);

    -127
    除了十进制,其他进制计算机存储的都是补码,运算的时候要站在计算机的角度。
    十进制可以站在用户的角度。

数的范围

有符号和无符号的区别:
有符号最高位是符号位,无符号最高位是数的一部分。无符号没有负数

有符号的数的范围:

正数:
0000 0000 ~ 0000 0111
0 ~ 127
负数:
1000 0000 ~ 1111 1111
-0 ~ -127
需要注意的是-0可以当作-128使用

原因:-128的原码和补码是一样的
原码:1 1000 0000
反码:1 0111 1111
补码:1 1000 0000

数值越界:原因计算机存储数据都是以二进制补码的形式来进行存储的
char a=127+2
printf("%d",2); //输出位-127

IDE调试

  1. 设置断点(F9)
  2. 调试运行(F5)
  3. 跳过函数(F10)
  4. 进入函数(F11)

字符数组和字符串的区别

  1. 字符数组是一个普通的数组,字符数组以"\0"或者数字0结尾就是字符串
  2. 打印的时候,普通数组无法一次性打印出来,但是字符数组和字符串可以通过%s一次性打印
  3. 如果字符数组没有结束符数字0,就会出现乱码(烫??烫),这也是常考的考点
  4. 数组名是常量,数组需要在初始化的时候指定占用的空间,否则编译器会报错
  5. C语言中没有字符串类型,用字符数组模拟
  6. 字符串一定是字符数组,但是字符数组不一定是字符串
  7. 字符数组的初始化可以用双引号

数组越界:数组越界,是指访问了超出数组定义的内容

  1. 编译时错误,语法错误
  2. 运行时错误,逻辑错误(编译时不会提示)
  3. VS会提示内存出现问题,卡住。

测试数组大小

sizeof(数组名)

冒泡排序,两个数相比较,大于交换,最大值放在最后

面试经常提问

打印地址

%p

字符0和\0

它们的ASCII码不同,打印会有所不同,‘0‘的ASCII码是48,\0的ASCII码是0

字符数组的输入

遇到空格截断scanf("%s", str); str=hello world输入的是hello,空格后面的字符放在了缓冲区
scanf()的缺陷,不做越界检查,所以这个安全隐患,VS不让用这个函数,除非加上了宏定义

随机数的产生

种子需要每次都改变,随机数才会发生改变,通常情况此下,用时间作为种子

gets和fgets函数

gets:这个函数已经被抛弃了,它的功能是从键盘读取字符串,放在指定的数组。它不作越界检查,函数不安全。
fgets:从标准输入读取内容,如果输入内容大于sizeof(buf)-1,只取sizeof(buf)-1个字符,放在buf数组,需要注意的是它会把字符也读取进去。

puts和fputs函数

puts:把buf内容输出到屏幕,自动在屏幕加换行,字符串本身没有换行符,是函数本身的。
fputs:和printf一样的效果,只是在文件操作时较为方便。

return和exit的区别

return:中断函数,中断main函数,程序停止
exit:结束整个程序(结束进程)

声明和定义的区别

  1. 在main函数中调用其他函数,只会往前找函数的定义
  2. 函数的声明就是把函数名字复制到main函数之前就可以了。
  3. 如果定义没有放在main函数前面,在调用函数前需要声明,声明加不加extern是一样的。
  4. 函数第一只能有一次,声明可以有多次
  5. 可以不定义只是声明,调用时会出错
  6. 声明的形参可以和定义的形参不同

分文件编程

  1. 按功能来分 xxx.h xxx.c
  2. 有一个主函数测试自定义函数 main.c
  3. 有一个不成文的规定,xx.c文件对应的头文件就是xx.h,文件名字一样的。
  4. 自定义的头文件include用双引号,系统定义的使用尖括号
  5. 在头文件中声明对应的.c文件中的函数,加不加extern关键字作用是一样的。
  6. 不能在头文件中定义函数,可以声明函数。对变量也是一样的。在头文件中定义函数,引用时有可能会出现多次定义的情况。

同一个文件如何防止多次包含:

  1. #pragma once //包含多次只有一次生效

  2. #ifndef _MyFunction

    #define _MyFunction

    #endif

分文件编程不一定是一个函数分一个函数

指针

运行程序,加载到内存,运行这的程序叫做进程

//定义变量,分配内存

每个字节的内存都有标号,这个标号就是地址,也叫指针

地址需要存储,32位编译器用32位(4字节)存此地址。

64位编译器用64位存地址

指针也是一种数据类型

p是一个变量,p的类型是int *,p的地址是&p,p里面存的也是一个地址,它存的是某个变量的地址。

*p等价于*(p+0)等价于p[0]。如果写成p[1]会产生越界错误,这是因为操作了野指针,它等价于操作了*(p+1)的内存,因为p+1这个地址是未知的。

*在定义变量是,它表示类型;在使用变量时,它代表操作指针所指向的内存

段错误:指的是非法操作内存,数组越界或者指针错误

野指针(常考):这个指针变量保存了一个没有意义(非法)的地址

合法地址:只有定义的变量后,这个地址就是合法的。

野指针本身没错,操作了非法地址才会出错。

操作系统中将0-255作为系统占用不允许访问操作。程序中允许存在野指针,使用野指针可能会报错。

不建议将变量的值直接赋值给指针。

空指针是指内存地址编号为0的空间,操作空指针一定会报错。空指针可以用于条件判断

数字0和‘\0‘和NULL都是一个意思,只不过NULL常用于指针,前两个多用于字符串。

多级指针:在需要保存变量地址的类型基础上加上一个*

万能指针:void不可以定义普通类型的变量,不能确定类型,就不能知道分配多大的空间。

可以定义void* 的变量,void*指针也叫万能指针

void*可以指向任何类型的变量(类型匹配),使用指针所指向的内存时,最好转换为它本身的指针类型(因为要指定明确的操作的内存空间大小)【*(int* p))】里面的int*就是指定了空间大小

上面说的指定的内存空间大小就是指的是指针步长。p+1指的是加的是一个步长,而不是数学上的1。步长由指针指向的数据类型决定。

不做类型转换,无法确定步长

const修饰的指针变量

面试经常问的:

const修饰,代表指针所指向的内存是只读:const int/int const p;

const修饰指针变量,代表指针变量的值为只读:int* const p = &a;

const同时修饰指针和变量,代表只读:const int * const p = &a;

数组和指针

数组名是常量,不允许修改,int* const p

指针数组

它是数组,每个元素都是指针

数组指针

它是指针,指向数组的指针

指针存在的意义

能够通过函数间接的操作内存。

如果想通过函数来改变实参,必须地址传递。

形参中的数组和非形参数组的区别

形参中的数组,不是数组,而是普通指针变量

形参数组:int a[10000],int a[],int a对编译器而言,没有任何区别,编译器都当作int 处理,64位系统中sizeof(a)的结果是8,而非数组的长度,sizeof(a[0])的结果就是4,因为第0个元素是int类型。

非形参的数组就是真的数组了

err,二维数组不是二级指针

函数指针

下面的程序面试会经常问到:

int* fun(){
    int a;
    return &a; //err
}
int main(){
    int* p=NULL;
    p=fun();
    *p=100;//操作了野指针
}

上面的代码在不同的平台运行有的会成功有的不会成功,但是是错误的(VS和Qt通过,Linux未通过)。因为当fun函数执行完毕后,变量a被释放。再次操作a的内存时就是操作了野指针。

linux64位gcc,不允许返回局部变量地址,因为返回后会无意义,会引起操作野指针的错误。

定义的全局变量可以解决上面的错误。

全局变量在任何地方都能使用,全局变量只有在整个程序结束后才释放。全局变量在data区存放

字符指针

%s:打印一个字符串

打印的时候%s会做一个额外的处理,所以会一次行打印出字符串,传入的是一个首元素的地址。

%s占位符,逗号后面对应的是一个地址,计算机会打印这个地址后面的所有字符,直到遇到\0停止打印。

%d,占位符,传入的的是一个变量,打印的也就是这个变量的值。

strcpy是拷贝给p所指向的内存空间拷贝内容,而不是给p拷贝内容。如果没有定义p指向的内存空间,就会出现操作野指针的错误(段错误)。

字符串

以字符串双引号形式初始化数组,自动隐藏结束符‘\0‘。
如果以单个字符类似数组的方式的赋值,打印%s会出现乱码。

每个字符串都是一个地址,这个地址是指字符串的首元素的地址

字符串常量放在data区,文字常量区。只读,不能修改。(面试经常考)
int* p = "hello"
strcpy(p,"abc")//error 段错误

main函数参数

main函数的参数:argv[]等价于*argv,也可以写成char* *argv

main函数的参数是由用户运行的时候传递的。

如果要指向上一个指针的地址,那就比上一个指针多一个*就可以了

查找匹配字符串出现的次数

strstr()函数的使用

字符串常量和字符指针数组

char* p1 = "abc" //存放在文字常量区的指针变量,不不能修改,可以拷贝到栈区就可以修改了

char p2[] = "abc" //存放在栈区,可以改变数组元素

char p3[100]; p3="abc"//err数组名是常量

内存管理

作用域和生命周期。

需要注意的就是当内存释放了就不要使用了,这是非法操作内存。

static局部变量,在编译阶段就已经分配了空间,函数没有调用前,就已经存在了。只有程序结束,static变量才自动释放。如果不做初始化,默认为0。这个语句只会初始化一次,但是可以赋值多次。

普通局部变量和static局部变量的区别

  1. 内存分配和释放
  2. 初始化

二级指针和字符指针数组

char** p。p是char**类型,指向char*类型

C语言全局变量的缺陷

C语言全局变量多次定义不会出现编译不会报错

int a;
int a;
int a;

上面的代码中有一次是定义,两次是声明。但是不能确定那个是定义。

如果定义一个全局变量,没有赋值(初始化),无法确定是定义还是声明。

如果定义一个全局变量,同时初始化,那么这个就是定义,其他语句是声明。

只有声明,没有定义,无法给变量赋值

因此,定义全局变量的同时,建议初始化,声明一个全局变量,加extern关键字。

全局变量分文件

在main函数里面或者外面声明都可以

使用函数前,声明函数

声明函数,extern可有可无

如果事先为声明,gcc编译会通过,但是会有警告,c++编译器不会通过。因此建议先声明函数,后使用。

声明不需要加头文件

头文件和.c文件

一般来讲头文件声明,.c文件声明不定义(对于同一个文件而言。)在main函数中直接包含头文件

全局变量在任何位置都只能定义一次,不管两个文件有没有关系。

如果在头文件中做定义,就可能会在预处理头文件展开时,会出现重复定义的问题。

普通全局变量和static全局变量的区别

  1. 普通全局变量是在{}外面定义的变量,全局变量所有文件只能有一个。普通全局变量所有文件都能使用。
  2. static全局变量一个文件只能有一个的定义,多个文件可以有多个,static全局变量只能在当前文件使用。
  3. 因此不同文件只能出现一个普通变量的定义
  4. 一个文件只能有一个static全局变量的定义,不同文件间的static全局变量,就算名字相同,也是没有关系的两个变量

面试会问:为了数据安全,把一个数据定义为static全局变量

static:内部链接

普通全局变量:外部链接

普通函数和static函数的区别和变量是一样的

auto变量:作用于一对{}内,声明周期为当前函数

内存分区(内存布局)

写代码一般不会用到,但是面试会可能会问到

size a.out #查看分区

在程序没有执行前,有几个内存分区已经确定,虽然分区确定,但是没有加载内存,程序只有运行时才加载内存。

  • text:(代码区)只读,主要放函数
  • data:初始化的数据,全局变量,static变量,文字常量区(只读)
  • bss:没有初始化的数据,全局变量,static变量

当运行程序,加载内存,首先根据前面确定的内存分区先加载,然后额外加载两个区:

  • stack:(栈区)普通局部变量,自动管理内存,先进后出的结构特点。
  • heap:(堆区)手动申请空间,手动释放,整个程序结束,系统也会自动回收。如果没有手动释放,程序也没有结束,这个堆区空间不会自动释放。

栈越界

栈越界就是栈区空间用光了

语法上没有问题,栈区分配很大的内存,越界了,导致段错误。段错误都是内存错误引起的。

这种错误通常是出现在函数递归的时候。

内存操作函数

和strcpy, strncpy, strcmp类似,但是如果是字符串,遇到\0结束是无法解决的。但是内存操作函数可以解决这个问题。

memset(&a, 97, sizeof(a));

其中97是以字符的ascii码来对a进行赋值的。主要用来清0数组

这个操作的第二个参数是针对字符来用的,不是整数。

其他函数:memcpy, memmove, memcmp

内存重叠

如果出现内存重叠,最好使用memmove代替memcpy

指针指向栈区空间

定义一个变量,指针指向该变量地址即可

指针指向堆区空间

使用malloc函数在堆区申请一个空间

参数指定堆区分配多大的空间malloc( sizeof(int) )

返回值,成功就是堆区空间的首元素地址,失败返回NULL

注意返回的地址是void*类型的,需要类型转换为int*,如果不转换,gcc编译可以通过,但是c++就会失败。

释放空间用free(p),不是释放p变量,而是释放p所指向的内存

同一块堆区空间只能释放一次

所谓的释放不是内存消失,而是指这块内存用户不能再使用,系统回收了,如果用户再次使用,就是使用野指针。

内存泄漏

动态分配了空间,不释放

int* p = NULL

.....

if(NULL != p)
{
    free(p);
    p = NULL;
}

内存污染

非法操作内存:操作野指针所指向内存,堆区越界

下面是错误代码,没有分配空间,但是却gcc编译成功。vs运行程序会卡死

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

int main(int argc, char *agrv[]){
    
    char *p = NULL;
    
    p = (char *)malloc(0); //没有分配空间
    if(p==NULL){
        printf("分配失败\n");
        return 0;
    }
    
    strcpy(p, "helloworld");
    printf("%s\n", p);
    
    free(p);
    
    return 0;
    
}

堆区越界

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

int main(int argc, char *agrv[]){
    
    char *p = NULL;

    p = (char *)malloc(0); //没有分配空间
    if(p==NULL){
        printf("分配失败\n");
        return 0;
    }

    strcpy(p, "helloworld");
    printf("%s\n", p);

    free(p);

    return 0;
}

为什么指针指向首元素就可以遍历整个数组

因为数组在内存中的存储是连续的

Java和C++封装了内存释放函数,用户只需要使用,但是C语言没有这种封装,所以会涉及到的内存问题较多。

堆区数组

p = (int * )malloc( 10 * sizeof(int) )

相当于在堆区开辟了类似栈区数组 int arr[10]; int *p = arr;

内存分区分析

值传递:

void fun(int *tmp){ //tmp存储在栈区空间
    tmp = (int *)malloc(sizeof(int) ); //操作堆区空间的内存
    *tmp = 100;
}

int main(int argc, char *argv[]){
    int *p = NULL;
    func(p); //值传递,形参修改不会影响实参
    printf("*p = %d\n", *p); //err,操作空指针
}

结构体

一个结构体变量就是C++中的一个对象

关键字 struct

struct Student{
    ;
}; //有分号,另一个就是do while了,两个特殊例子

struct Student合起来才是结构体类型名字

结构体内部定义的变量不能直接赋值

结构体只是一个类型,没有定义变量前,是没有分配空间的,没有分配空间,就不能赋值。

struct Student stu;//定义变量

结构体变量初始化,和数组一样,要使用大括号,而且只有在定义时才能初始化。

struct Student stu2 = {10, "mike", 40};

如果是普通变量,使用点运算符赋值。

如果是指针变量,使用->运算符;如果是指针,指针有合法指向,才能操作结构体成员。

任何结构体变量都可以用点或者箭头操作成员

C语言基础补充

标签:null   har   情况   分析   最大值   手动   主函数   字符   针对   

原文地址:https://www.cnblogs.com/thethomason/p/9831713.html

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码!