C语言复习（1）

运算符&：获得变量的地址，操作数必须是变量

输出地址用%p

地址和整数不永远相同，与架构（32位/64位）有关

&右边一定要有一个明确的变量

指针–保存地址的变量

int i;
int *p = &i;
int* p , q;		//p是指针，q是普通的int类型的变量，下一行一样
int *p , q;

变量的值是内存的地址

? 普通变量的值是实际的值

? 指针变量的值是具有实际值的变量的地址

像 a[0] , *p ，不是变量，而是表达式运算的结果。是特殊的值

指针应用场景：

函数返回多个值，某些值就只能通过指针返回

? 传入的参数实际上是需要保存带回的结果的变量

? 函数返回运算的状态，结果通过指针返回

指针最常见的错误：

定义了指针变量，还没有指向任何一个变量，就开始使用指针

函数参数表中的数组实际上是指针

? sizeof(a) == sizeof(int *)

? 但是可以用数组的运算符[]进行运算

//以下四种函数原型是等价的：
int sum ( int *ar , int n);
int sum ( int * , int);
int sum ( int ar[] , int n);
int sum ( int [] , int);

数组变量是特殊的指针

数组变量本身表达地址，所以

? int a[10] ; int *p = a; 无需用&取地址

? 但是数组的单元表达的是变量，需要用&取地址

? a == &a[0]

[]运算可以对数组做，也可以对指针做

? p[0] <==> a[0]

*运算符可以对指针做，，也可以对数组做

数组变量是 const 的指针，所以不能被赋值

int *q --> int * const b		//b是一个常数，不能被改变

以下只适用于C99

指针是const

表示一旦得到了某个变量的地址，不能再指向其他变量

int * const q = &i ;		//q 是 const

*q = 26 ;		//OK
q++ ;			  //ERROR

所指是const

表示不能通过这个指针去修改那个变量（并不能使得那个变量成为const）

const int *p = &i ;

*p = 26 ;		//ERROR!	( *p ) 是 const
i = 26 ;		//OK
p = &j ;		//OK

辨析：

int i ;
const int* p1 = &i ;	//所指的东西不能被修改
int const* p2 = &i ;	//同上一个
int *const p3 = &i ;	//指针不能被修改
//判断那个被 const 了的标志是 const 在 * 的前面还是后面

转换

总是可以把一个非const的值转换成const的

viod f(const int* x);
int a = 15 ;
f(&a); //OK
const int b = a ;

f(&b); //OK

b = a + 1; //ERROR!

当要传递的参数的类型比地址大的时候，这是常用的手段：既能用比较少的字节数传递值给参数，又能避免函数对外面的变量的修改

const 数组

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

数组变量已经是 const 的指针了，这里的 const 表明数组的每个单元都是 const int

所以必须通过初始化进行赋值

保护数组值

因为把数组传入函数时传递的是地址，所以那个函数内部可以修改数组的值

为了保护数组不被函数破坏，可以设置参数位 const

? int sum (const int a[] , int length) ;

以上适用于C99

sizeof ( char ) = 1 , sizeof( int ) = 4

*p++

取出p所指的那个数据来，完事之后顺便把p移到下一个位置去

*的优先级虽然高，但是没有++高

常用于数组类的连续空间操作

在某些CPU上，这可以直接被翻译成一条汇编指令

指针比较

< , <= , == , > , >= , != 都可以对指针做

比较它们在内存中的地址

数组中的单元的地址肯定是线性递增的

0地址

当然你的内存中有0地址，但是0地址通常是一个不能随便碰的地址

所以你的指针不应该具有0值

因此可以用0地址来表示特殊的事情：

? 返回的指针是无效的

? 指针没有真正初始化（先初始化位0）

NULL是一个预定的符号，表示0地址

? 有的编译器不愿意你用0来表示0地址

指针的类型

无论指向什么类型，所有的指针的大小都是一样的，因为都是地址

但是指向不同的类型的指针是不能直接互相赋值的

这是为了避免用错指针

指针的类型转换

void* 表示不知道指向什么东西的指针

? 计算时与char*相同 （但不相通）

指针也可以转换类型

? int *p = &i ;

? void*q = (void *)p ;

这并没有改变p所指的变量的类型，而是让后人用不同的眼光通过p看它所指的变量

? 我不再当你是int 啦，我认为你就是个void !

用指针来做什么

需要传入较大的数据时用作参数

传入数组后对数组做操作

函数返回不止一个结果

? 需要用函数来修改不止一个变量

动态申请的内存……

动态内存分配

输入数据

如果输入数据时，先告诉你个数，然后再输入，要记录每个数据

C99可以用变量做数组定义的大小，C99之前呢？

int *a = (int *)malloc(n*sizeof(int));

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

int main(void)
{
    int number;
    int *a;
    int i;
    printf("输入数量：");
    scanf("%d",&number);
    //int a[number];  //C99
    a = (int*)malloc(number*sizeof(int));
    for(i = 0 ; i<number ; i++ ){
        scanf("%d",&a[i]);
    }
    for( i = number - 1 ; i>=0 ; i--){
        printf("%d ",a[i]);
    }
    free(a);
    return 0 ;
}

malloc

#include<stdlib.h>

void* malloc(size_t size);

向malloc申请的空间大小是以字节为单位的

返回的结果时void*，需要类型转换为自己需要的类型

(int*)malloc(n*sizeof(int));

没空间了？

如果申请失败则返回0，或者叫做NULL

你的系统能给你多大的空间？

free()

把申请得来的空间还给“系统”

申请过的空间，最终都应该要还（混出来的，迟早都是要还的）

只能还申请来的空间的首地址

常见问题

申请了没free——>长时间运行内存下降

? 新手：忘了

? 老手：找不到合适的free时机

free过了再free

地址变过了直接去free

文件输入输出

用>和<做重定向

FILE

FILE* fopen(const char* restrict path , const char*restrict mode);

int fclose(FILE *stream);

fscanf(FILE*,...)
    
fprintf(FILE*,...)

打开文件的标准代码

FILE *fp = fopen("file","r");
if( fp ){
    fscanf(fp,...);
    fclose(fp);
}else{
    ...
}

#include<stdio.h>

int main(int argc , char const *argv[])
{
    FILE *fp = fopen("12.in", "r");
    if( fp ) {
        int num;
        fscanf(fp, "%d" , &num);
        printf("%d\n" , num);
        fclose( fp );
    }else{
        printf("无法打开该文件\n");
    }
    return 0 ;
}

fopen

buf

buf是英文buffer的缩写，意思是缓冲区， 它本质上就是一段存储数据的内存。

1、在C语言编程中一般用数组来表示一个缓冲区。如下：

char` `buf[256] = {0}; ``//定义一个数组作为缓冲区。``scanf``(``"%s"``, buf);   ``//向缓冲区中输入数据``printf``(``"%s"``, buf);  ``//输出缓冲区的内容

2、C语言编译器生成程序后，每个程序自身的运行也需要缓冲区，一般叫做堆栈，它们的默认大小一般是1MB。

3、如果数据超出了缓冲区的大小，即为溢出，在C语言中如果用户定义的数组在栈区，当发生溢出时，称做栈溢出，如果用户定义的数组在堆区，当发生溢出时，称为堆溢出，溢出不仅可能导致程序崩溃，而且可能会给程序带来安全性问题。因此，在使用缓冲区时，一定要注意缓冲区是否能容纳下相应的数据。