c语言提高学习笔记——02-c提高02day

在学习c语言提高总结了笔记，并分享出来。有问题请及时联系博主：Alliswell_WP，转载请注明出处。

02-c提高02day

目录：
1、函数调用模型
2、调用惯例
3、函数变量传递分析
4、栈的生长方向和内存存放方向
5、指针
（1）指针变量
（2）野指针和空指针
1）空指针
2）野指针
（3）间接访问操作符
（4）指针的步长
（5）指针的意义_间接赋值
（6）指针做函数参数
（7）字符串指针强化
1）字符串指针做函数参数
2）字符串拷贝
3）字符串反转
 （8）sprintf

1、函数调用模型

注意：宏函数并不是真正的函数！真正的函数有返回值，参数和函数体。

使用宏函数是因为在一定场景下宏函数效率要比函数高！（宏函数只是预处理器进行简单的文本替换。不过是以空间换时间。）对于频繁使用，并且短小的函数，我们一般使用宏函数代替，因为宏函数没有普通函数调用的开销（函数压栈、跳转、返回等）

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

#define MYADD(x,y) ((x)+(y)) //宏函数

int main(){
    int a = 10;
    int b = 20;

    printf("a+b=%d
", MYADD(a,b));

    system("pause");
    return EXIT_SUCCESS;
｝

没有栈就没有函数？

栈（stack)是现代计算机程序里最为重要的概念之一，几乎每一个程序都使用了栈，没有栈就没有函数，没有局部变量，也就没有我们如今能见到的所有计算机的语言。在解释为什么栈如此重要之前，我们先了解一下传统的栈的定义：
在经典的计算机科学中，栈被定义为一个特殊的容器，用户可以将数据压入栈中（入栈，push)，也可以将压入栈中的数据弹出（出栈，pop),但是栈容器必须遵循一条规则：先入栈的数据最后出栈（First In Last Out,FILO).
在经典的操作系统中，栈总是向下增长的。压栈的操作使得栈顶的地址减小，弹出操作使得栈顶地址增大。
栈在程序运行中具有极其重要的地位。最重要的，栈保存一个函数调用所需要维护的信息，这通常被称为堆栈帧（Stack Frame)或者活动记录（Activate Record).一个函数调用过程所需要的信息一般包括以下几个方面：
■函数的返回地址；
■函数的参数；
■临时变量；
■保存的上下文：包括在函数调用前后需要保持不变的寄存器。

int func(int a,int b){

int t_a=a；
int t_b=b；

return t_a+t_b；
}

int main(){

int ret=0;
   ret = func(10,20)；
int a=20；

return EXIT_SUCCESS；
}

注意：1）左侧30为寄存器中的值。

2）返回地址为下一条指令要执行的地址！

图中问题1和2由2、调用惯例解决！

2、调用惯例

现在，我们大致了解了函数调用的过程，这期间有一个现象，那就是函数的调用者和被调用者对函数调用有着一致的理解，例如，它们双方都一致的认为函数的参数是按照某个固定的方式压入栈中。如果不这样的话，函数将无法正确运行。

如果函数调用方在传递参数的时候先压入a参数，再压入b参数，而被调用函数则认为先压入的是b，后压入的是a，那么被调用函数在使用a,b值时候，就会颠倒。（1中图中第1个问题）

因此，函数的调用方和被调用方对于函数是如何调用的必须有一个明确的约定，只有双方都遵循同样的约定，函数才能够被正确的调用，这样的约定被称为”调用惯例（Calling Convention)"一个调用惯例一般包含以下几个方面：

函数参数的传递顺序和方式
函数的传递有很多种方式，最常见的是通过栈传递。函数的调用方将参数压入栈中，函数自己再从栈中将参数取出。对于有多个参数的函数，调用惯例要规定函数调用方将参数压栈的顺序：从左向右，还是从右向左。有些调用惯例还允许使用寄存器传递参数，以提高性能。

栈的维护方式

在函数将参数压入栈中之后函数体会被调用此后需要将被压入栈中的参数全部弹出，以使得栈在函数调用前后保持一致。这个弹出的工作可以由函数的调用方来完成，也可以由函数本身来完成。

为了在链接的时候对调用惯例进行区分，调用惯例要对函数本身的名字进行修饰。不同的调用惯例有不同的名字修饰策略。

事实上，在c语言里，存在着多个调用惯例，而默认的是cdecl.任何一个没有显示指定调用惯例的函数都是默认是cdecl惯例。比如我们上面对于func函数的声明，它的完整写法应该是：
int_cdecl func(int a,int b);

注意：cdecl不是标准的关键字，在不同的编译器里可能有不同的写法，例如gcc里就不存在cdecl 这样的关键字，而是使用_attribute((cdecl)).

（1中图中第2个问题）由cdecl知道出栈方为函数调用方，所以函数参数销毁由main函数完成。

3、函数变量传递分析

4、栈的生长方向和内存存放方向

//1.栈的生长方向

void test01(){

int a=10；
int b=20；
int c=30；
int d=40；

printf("a=sd
",&a);
printf("b=sd
",&b);
printf("c=sd
",&c)；
printf("d=sd
",&d);
//a的地址大于b的地址，故而生长方向向下
}

//2.内存生长方向（小端模式）
void test02(){

//高位字节->地位字节
int num=0xaabbccdd;//4个字节的16进制数
unsigned char* p=#

//从首地址开始的第一个字节
printf("%x
",*p)；
printf("%x
"，*(p+1))；//p+1的地址比p的地址高
printf("%x
"，*(p+2))；
printf("%x
"，*(p+3))；
}

 分析如下：

5、指针

char *说到底只是一个地址的序号，无论是char *p,还是double *p，其字节数只和计算机的位数相关，和其数据类型默认所占大小无关。32位系统占4个字节，64位系统占8个字节！

指针是一种数据类型
（1）指针变量
指针是一种数据类型，占用内存空间，用来保存内存地址。

 （2）野指针和空指针

1）空指针
标准定义了NULL指针，它作为一个特殊的指针变量，表示不指向任何东西。要使一个指针为NULL，可以给它赋值一个零值。为了测试一个指针百年来那个是否为NULL，你可以将它与零值进行比较。

对指针解引用操作可以获得它所指向的值。但从定义上看，NULL指针并未执行任何东西，因为对一个NULL指针因引用是一个非法的操作，在解引用之前，必须确保它不是一个NULL指针。

如果对一个NULL指针间接访问会发生什么呢？结果因编译器而异。

不允许向NULL和非法地址拷贝内存：

void test(){
    char* p=NULL；
    //给p指向的内存区域拷贝内容
    strcpy(p,"1111"）；//err

    char* q=0x1122；
    //给q指向的内存区域拷贝内容

    strcpy(q,"2222"）；//err

}

 2）野指针

在使用指针时，要避免野指针的出现：
野指针指向一个已删除的对象或未申请访问受限内存区域的指针。与空指针不同，野指针无法通过简单地判断是否为NULL避免，而只能通过养成良好的编程习惯来尽力减少。对野指针进行操作很容易造成程序错误。

什么情况下回导致野指针?
■指针变量未初始化
任何指针变量刚被创建时不会自动成为NULL指针，它的缺省值是随机的，它会乱指一气。所以，指针变量在创建的同时应当被初始化，要么将指针设置为NULL，要么让它指向合法的内存。

■指针释放后未置空
有时指针在free或delete后未赋值NULL，便会使人以为是合法的。别看free和delete的名字（尤其是delete），它们只是把指针所指的内存给释放掉，但并没有把指针本身干掉。此时指针指向的就是“垃圾”内存。释放后的指针应立即将指针置为NULL，防止产生“野指针"。

■指针操作超越变量作用域
不要返回指向栈内存的指针或引用，因为栈内存在函数结束时会被释放。

void test(){
    int* p = 0x001;//未初始化
    printf("%p
"，p）;
    *p = 100;
}

操作野指针是非常危险的操作，应该规避野指针的出现：
■初始化时置NULL
指针变量一定要初始化为NULL，因为任何指针变量刚被创建时不会自动成NULL指针，它的缺省值是随机的。

■释放时置NULL
当指针p指向的内存空间释放时，没有设置指针p的值为NULL。delete和free只把内存空间释放了，但是并没有将指针p的值赋为NULL。通常判断一个指针是否合法，是使用if语句测试该指针是否为NULL。

（3）间接访问操作符

通过一个指针访问它所指向的地址的过程叫做间接访问，或者叫解引用指针，这个用于执行间接访问的操作符是*。

注意：对一个int*类型指针解引用会产生一个整型值，类似地，对一个float*指针解引用会产生了一个float类型的值。

在指针声明时，*号表示所声明的变量为指针

在指针使用时，*号表示操作指针所指向的内存空间

1）*相当通过地址（指针变量的值）找到指针指向的内存，再操作内存

2）*放在等号的左边赋值（给内存赋值，写内存）

3）*放在等号的右边取值（从内存中取值，读内存）

（4）指针的步长

指针是一种数据类型，是指它指向的内存空间的数据类型。指针所指向的内存空间决定了指针的步长。指针的步长指的是，当指针+1时候，移动多少字节单位。

思考如下问题？

int a = 0xaabbccdd;
unsigned int* pl = &a;
unsigned char* p2 = &a;

//为什么*加1打印出来正确结果?
printf("%x
",*p1)；
//为什么*p2没有打印出来正确结果?
printf("%x
",*p2)；

//为什么p1指针+1加了4字节?
printf("pl =sd
",pl);
printf("pl+1=%d
",pl +1);

//为什么p2指针+1加了1字节？
printf("p2 =sd
",p2)；
printf("p2+1=%d
",p2+1);

深入理解

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


void test01()
{
    char buf[1024] = {0};
    int a = 100;
    memcpy(buf+1, &a, sizeof(int));
    
    char* p = buf;
    //如何取出100？(p+1)先定位至100的其实地址，然后(int*)(p+1)取出四个字节，最后解引用
    printf("*(int*)(p+1) = %d
", *(int*)(p+1));
}

int main(){

    test01();
    
    system("pause");
    return EXIT_SUCCESS;
}

加深理解

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#include<stddef.h> //计算偏移量

　　using namespace std;


struct Person
{
    int a;
    char b;
    char buf[64];
    int d;
};

void test()
{
    struct Person p = {10, 'a', "hello world!", 100};
    //测试b偏移量
    printf("a off:%d
", offsetof(struct Person, b));
    //&p取到p的首地址，(char*)&p偏移量每次一个字节，offsetof(struct Person, d)计算d相对于结构体的总量，((int*)((char*)&p + offsetof(struct Person, d)))计算得到d存储的偏移地址
    printf("*((int*)((char*)&p + offsetof(struct Person, d))) off:%d
", *((int*)((char*)&p + offsetof(struct Person, d))));//输出100
    
}

int main(){

    test();
    
    system("pause");
    return EXIT_SUCCESS;
}

（5）指针的意义_间接赋值
1）间接赋值的三大条件
通过指针间接赋值成立的三大条件：
【1】2个变量（一个普通变量一个指针变量、或者一个实参一个形参）
【2】建立关系
【3】通过*操作指针指向的内存

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

void changeValue(int* p)
{
    *p = 100;
}

void test()
{
    int a = 10;
    changeValue(&a);
    printf("%d
", a);
}



int main(){

    test();
    
    system("pause");
    return EXIT_SUCCESS;
}

 因为QT每次分配的内存空间固定，可直接操作内存空间。

#include <stdio.h>

int main(int argc,char *argv[])
{
    int a = 10；

    printf("%d
",&a);

    //先执行前两行代码，确定内存地址，如：2686652，然后操作内存地址

    *(int*）2686652 = 100；//类似于int* p = 2686652; *p = 100;
    
    printf("a = %d
",a)；

    return 0；
}

深入理解（二级指针）：

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

void changePointer(int** val)
{
    *val = 0x008;
}

void test()
{
    int* p =NULL;
    changePointer(&p);
    
    printf("p = %x
", p);
}



int main(){

    test();
    
    system("pause");
    return EXIT_SUCCESS;
}

间接赋值的推论
·用1级指针形参，去间接修改了0级指针（实参）的值。
·用2级指针形参，去间接修改了1级指针（实参）的值。
·用3级指针形参，去间接修改了2级指针（实参）的值。
·用n级指针形参，去间接修改了n-1级指针（实参）的值。

（6）指针做函数参数
指针做函数参数，具备输入和输出特性：
■输入：主调函数分配内存
■输出：被调用函数分配内存

1.主调函数分配内存，被调函数使用内存，指针的输入特性

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

1.主调函数分配内存，被调函数使用内存，指针的输入特性
void printString(const char* val)
{
    printf("打印内容：%s
", str);
}

//打印指针数组
void printStringArray(char** arr, int len)
{
    //arr[0]等价于*(arr + 0)，是char*类型的
    for(int i = 0; i < len; ++i)
    {
        printf("%s
", arr[i]);
    }
}

//打印数组
void printIntArray(int* arr, int len)
{
}

void test()
{
    //堆上分配内存，注意这种用法！
    char* s = malloc(sizeof(char)* 100);
    memset(s, 0, 100);
    strcpy(s, "I am Polly!");
    printString(s);
    
    //数组名左函数参数就会退化为指向数组首元素的指针
    int arr[] = {1, 2, 3, 4, 5};
    
    
    //栈上分配
    char* strs[] = {"aaaaa","bbbbb", "ccccc", "ddddd", "eeeee"};
    int len = sizeof(strs)/sizeof(strs[0]);//等价于len = sizeof(strs)/sizeof(char*);
    printStringArray(strs, len);
    
}

int main(){

    test();
    
    system("pause");
    return EXIT_SUCCESS;
}

2.输出特性：被调函数分配内存，主调函数使用内容

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

2.输出特性：被调函数分配内存，主调函数使用内容
void allocateSpace(char** temp)
{
    char* p = malloc(100);
    memset(p, 0, 100);
    strcpy(p, "hello world!");
    *temp = p;
}


void test()
{
    char* p = NULL;
    allocateSpace(&p);
    printf("p = %s
", p);
    
    if(p != NULL)
    {
        free(p);
        p = NULL;
    }
}

int main(){

    test();
    
    system("pause");
    return EXIT_SUCCESS;
}

（7）字符串指针强化

1）字符串指针做函数参数

字符串基本操作

//字符串基本操作
//字符串是以0或者’'结尾的字符数组，（数字0和字符’'等价）
void test(){
//字符数组只能初始化5个字符，当输出的时候，从开始位置直到找到0结束
char strl[]={'h','e','1','1','o'};
printf（"%s
"，str1);

//字符数组部分初始化，剩余填0
char str2[100]={'h','e','1','1','o'};
printf（"%s
"，str2）;

//如果以字符串初始化，那么编译器默认会在字符串尾部添加’'
char str3[]="hello";
printf("%s
"，str3);
printf（"sizeof str:%d
"，sizeof(str3));
printf（"strlen str:%d
",strlen(str3));

//sizeof计算数组大小，数组包含’'字符
//strlen计算字符串的长度，到’'结束

//那么如果我这么写，结果是多少呢?
char str4[100]="hello";
printf("sizeof str:%d
",sizeof(str4));
printf("strlen str:%d
",strlen(str4));

//请问下面输入结果是多少？sizeof结果是多少？strlen结果是多少?
char str5[]="helloworld";
printf("%s
"，str5);
printf("sizeof str5:%d
",sizeof(str5));
printf("strlen str5:%d
"，strlen(str5));

//再请问下面输入结果是多少？sizeof结果是多少?strlen结果是多少？
char str6[]="hello12world";
printf("%s
",str6);
printf("sizeof str6:%d
",sizeof(str6));
printf("strlen str6:%d
"，strlen(str6));
}

2）字符串拷贝

三种方法：

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

//1.字符串拷贝
void copyString01(char* dst, const char* source)
{
    int len = strlen(source);
    for(i = 0; i < len; ++i)
    {
        dst[i] = source[i];
    }
    dst[len] = '';
}
//指针拷贝
void copyString02(char* dst, const char* source)
{
    while(*source)//等价于*source != ''
    {
        *dst = *source;
        ++dst;
        ++source;
    }
    *dst = '';
}

void copyString03(char* dst, const char* source)
{
    while(*dst++ == *source);
}

void test()
{
    char* source = "hello world!";
    char buf[1024] = {0};//拷贝如果未初始化，会报错，怎么解决？1.初始化 2.加''
    //copyString01(buf, source);
    //copyString02(buf, source);
    copyString03(buf, source);
    printf("%s
", buf);
}

int main(){

    test();
    
    system("pause");
    return EXIT_SUCCESS;
}

3）字符串反转

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

//2.字符串反转
void reverseString(char* str)
{
    if(NULL == str)
    {
        return;
    }
    int len = strlen(str);
    int start = 0;
    int end = len - 1;
    while(start < end)
    {
        char temp = str[start];
        str[start] = str[end];
        str[end] = temp;
        ++start;
        --end;
    }
}


void test()
{
    char p[] = "hello world!";//不能写成char* p = "hello world!";
    reverseString(p);
    printf("p = %s
", p);
}

int main(){

    test();
    
    system("pause");
    return EXIT_SUCCESS;
}

字符串反转，法二：指针操作

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

//2.字符串反转，法二：指针操作
void reverseString(char* str)
{
    if(NULL == str)
    {
        return;
    }
    int len = strlen(str);
    char* pStart = str;
    char* pEnd = str + len - 1;
    
    while(pStart < pEnd)
    {
        char temp = *pStart;
        *pStart = *pEnd;
        *pEnd = temp;
        ++pStart;
        --pEnd;
    }

}


void test()
{
    char p[] = "hello world!";//不能写成char* p = "hello world!";
    reverseString(p);
    printf("p = %s
", p);
}

int main(){

    test();
    
    system("pause");
    return EXIT_SUCCESS;
}

 （8）sprintf

#include<stdio.h〉
int sprintf(char *str,const char *format,..…)；
功能：
    根据参数format字符串来转换并格式化数据，然后将结果输出到str指定的空间中，直到出现字符串结束符’0'为止。
参数：
    str：字符串首地址
    format：字符串格式，用法和printfO一样
返回值：
    成功：实际格式化的字符个数
    失败：-1

测试代码：

void test(){
    //1.格式化字符串
    char buf[1024] = {0};
    sprintf(buf, "你好，%s，欢迎加入我们！","John");
    printf("buf:%s
", buf);
    
    memset(buf, 0, 1024);
    sprintf(buf, "我今年%d岁了", 20);
    printf("buf:%s
", buf);
    
    2.拼接字符串
    memset(buf, 0, 1024);
    char str1[] = "hello";//或char* str1
    char str2[] = "world";//或char* str2
    int len = sprintf(buf,"%s %s", str1, str2);
    printf("buf:%s len:%d
", buf, len);
    
    3.数字转字符串
    memset(buf, 0, 1024);
    int num = 100;
    sprintf(buf, "%d", num);
    printf("buf:%s
", buf);
    //设置宽度 右对齐
    memset(buf, 0, 1024);
    sprintf(buf, "%8d", num);
    printf("buf:%s
", buf);
    //设置宽度 左对齐
    memset(buf, 0, 1024);
    sprintf(buf,"%-8d", num);
    printf("buf:%s
", buf);
    //转成16进制字符串 小写
    memset(buf, 0, 1024);
    sprintf(buf, "0x%x", num);
    printf("buf:%s
", buf);
    
    //转成8进制字符串
    memset(buf, 0, 1024);
    sprintf(buf, "0%o", num);
    printf("buf:%s
", buf);
    
}

---

备注：memset()函数原型是extern void *memset(void *buffer, int c, int count) buffer：为指针或是数组,c：是赋给buffer的值,count：是buffer的长度.

memset：作用是在一段内存块中填充某个给定的值，它是对较大的结构体或数组进行清零操作的一种最快方法。

---

深入理解

    4.深入理解
    char** p = malloc(sizeof(char*)* 5);//先开辟20个字节的空间堆空间
    for(int i = 0; i < 5; ++i)
    {
        p[i] = malloc(64); //为每个值再开辟堆空间,64个字节
        memset(p[i], 0, 64);
        sprintf(p[i], "Name_%d", i + 1);
    }
    
    //打印字符串
    for(int i = 0; i < 5; ++i)
    {
        printf("%s
", p[i]);
    }
    
    //释放内存
    for(int i = 0; i < 5; ++i)
    {
        if(p[i] != NULL)
        {
            free(p[i]);//释放第二层
            p[i] = NULL;
        }
    }
    if(p != NULL)
    {
        free(p);//释放第一层
        p = NULL;
    }

参考：

1）讲义：豆丁网：https://www.docin.com/p-2159552288.html
道客巴巴：https://www.doc88.com/p-6951788232280.html

2）C语言 字符指针大小——https://blog.csdn.net/qq_29566629/article/details/104756337

3） C 库函数 - malloc()？——https://www.runoob.com/cprogramming/c-function-malloc.html

4）memset？百度百科——https://baike.baidu.com/item/memset/4747579?fr=aladdin

在学习c语言提高总结了笔记，并分享出来。有问题请及时联系博主：Alliswell_WP，转载请注明出处。