C语言深度剖析 --- 【关键字】

已于 2024-05-17 13:28:00 修改
阅读量671 收藏 14
点赞数 28
分类专栏： C语言深入学习 文章标签： c语言 c++ 算法
于 2024-03-15 00:01:30 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zhongziqia/article/details/136725387
版权

文章目录

C语言深入解剖

1.关键字

1.1 最宽宏大量的关键字 — auto

相关：一般在代码中所定义的变量，即局部变量，默认是auto所修饰的，但一般都是省略的。不是所有的变量都是auto，它一般用来修饰局部变量。

nt main()
{
    int i = 0;
    for (i = 0; i < 10; i++)
    {
        printf(" i = %d\n", i);
        if (1)
        {
            auto int j = 0;  //自动变量(局部变量)
            printf("1. j = %d\n", j);
            j += 1;
            printf("2. j = %d\n", j);
        }
    }
    return 0;
}
1.2 最快的关键字 — register

CPU主要进行计算硬件单元，为了方便计算，一般要先把数据从内存中读取到CPU内，所以CPU是需要具备一定的数据临时存储能力。在现代CPU内，集成了一组叫寄存器的硬件，用来进行临时数据的保存。寄存器在硬件层面上来看，它能够有效地提高运算效率，因为不需要从内存中读取数据。

register修饰变量

什么样的变量，可采用register？

1.局部的

2.不被写入的

3.高频被读取的

4.使用时不能大量使用，寄存器数量有限

#include <stdio.h>

int main()
{
    register int x = 0;
    printf("x = %d\n", &x);
    //编译后会报错，register修饰的变量不能取地址。
    //不是所有的编译器都会报错，目前用的vs2019报错了。
    return 0;
}
1.3 最名不副实的关键字 — static

相关：

static修饰全局变量时，该变量只能在本文件内访问，不能被外部文件直接访问。

static修饰局部变量时，该变量的生命周期改变，作用域不变。

static修饰函数时，该函数只能在本文件内被访问，不能在外部文件直接访问。

static有助于项目的维护，提供安全的保证。

//main.c
#include <stdio.h>

extern int b;
extern int Max(int x, int y);
//static void fr()
//{
//    int i = 0;
//    printf("i = %d\n", i );
//    i += 1;
//}
//局部变量i,因为居于临时性
//函数调用时会开辟空间并初始化
//函数结束后释放空间


static void fr()
{
    static int i = 0;
    printf("i = %d\n", i);
    i += 1;
}

int main()
{
    static int a = 10;
    printf("a = %d\n", a );
    printf("b = %d\n", b);
    int i = 0;
    for (i = 0; i < 10; i++)
    {
        fr();
    }
    return 0;
}

//test.c
#include <stdio.h>

static int b = 20;

static int Max(int x, int y)
{
    if (x > y)
        return x;
    else
        return y;
    return 0;
}
1.4 基本数据类型

相关：

定义一个变量，是需要类型的，类型决定了开辟空间的大下。

#include <stdio.h>

int main()

{
    printf("%d\n", sizeof(char));        //1
    printf("%d\n", sizeof(short));        //2
    printf("%d\n", sizeof(int));        //4
    printf("%d\n", sizeof(long));        //4
    printf("%d\n", sizeof(long long));  //8
    printf("%d\n", sizeof(float));        //4
    printf("%d\n", sizeof(double));        //8
    return 0;
}
变量命名规则

1.命名直观且可读，便于阅读和记忆。标识符最好采用英文单词或其组合，不许使用拼音。

2.命名长度应符合“min-length && max - information”原则。如MinVal比MinValueUnitOverflow好用。

3.当标识符由多个词所组成，每个词的第一个字母大写，其他全部小写。如：int MaxVal;。

4.尽量避免名字中出现数字编号，比如Val1，Val2等，除非逻辑上需要编号。

5.在多个文件之间共同使用的全局变量或函数要加范围限定符，如TEST_等。

6.作用域前缀命名，比如标识符：Global Variable，作用域前缀：g。

7.数据类型前缀命名，比如int iMax = 10;。

8.程序中不得出现仅靠大小写区分的相似的标识符。如：int x, X；int o , O, int i , I;

9.一个函数名禁止被用于其他处。如：

void test(int x)

{

int a = 1;

}

void pr(void)

{

int test = 2;

}

10.所有宏定义、枚举常数、只读变量全用大写字母进行命名，使用下划线分割。如：#define INT_MAX 100

11.局部变量中可采用通用命名方式，仅限于n、j、k等作为循环变量使用。如：i、j、k。

12.结构体被定义时必须有明确的结构体名

13.定义变量的同时别忘记初始化。

14.不同类型数据之间的运算注意精度扩展问题，一般低精度向高精度扩展。

1.5 最冤枉的关键字sizeof理解

1.5.1 常年被误认为函数
#include <stdio.h>

int main()
{
    int a = 10;
    printf("%d\n", sizeof (a));  //1
    printf("%d\n", sizeof(int)); //2
    printf("%d\n", sizeof a);    //3
    printf("%d\n", sizeof int);  //4
    //1、2、3是正确的
    //4是错误的,int是关键字不能直接使用sizeof关键字
    //sizeof不是函数，它是关键字或是操作符
    return 0;
}
1.5.2 sizeof(int)*p表示什么意思
#include <stdio.h>

int main()
{
    int* p = NULL;
    int arr[10] = { 0 };
    int* test[2];

    printf("%d\n", sizeof(p));   //4
    printf("%d\n", sizeof(arr)); //40
     printf("%d\n", sizeof(test));//8
    return 0;
}

1.6 signed、unsigned关键字

有符号整数与无符号整数
char 
    unsigned char
    signed char

short
    unsigned short[int]
    signed short[int]

int 
    unsigned int
    signed int

long
    unsigned long[int]
    signed long[int]
原码、反码、补码

创建一个变量需要在内存中开辟空间，空间的大小由不同的类型所决定，数据在所开辟内存中如何存储呢？

有符号数：

#include <stdio.h>

int main()
{
    int a = 10;
    //0000 0000 0000 0000 0000 0000 0000 1010

    int b = -20;
    //1000 0000 0000 0000 0000 0000 0001 0100 原码
    //1111 1111 1111 1111 1111 1111 1110 1011 反码
    //1111 1111 1111 1111 1111 1111 1110 1100 补码

    //补码->原码
    //方法1：先-1，然后符号位不变，按位取反。
    //方法2：先符号位不变，按位取反，然后+1。

    //对于有符号数，它一定是能够表示数值为正数或负数的，一般最高比特位表示符号位。
    //在计算机中有三种有符号数的表示方式：原码、反码、补码。
    // 任何数据在计算机中，都需要转换成二进制，因为计算机只认识二进制。
    //三种表示方式都有符号位和数值位两部分，其中符号位用1表示‘负’，使用0表示‘正’，数值位三种表示方式各有不同。

    //如果一个数值为负数，那么它应该按照原码->反码->补码进行转化。
    //原码：将二进制按照正负数形式转换成二进制即可。
    //反码：原码的符号位不变，其他按位取反。
    //补码：反码+1。

    //如果一个数值为正数，那么它的原码、反码和补码都相同。

    return 0;
}

无符号数：不需要进行转化，也不需要符号位，原反补相同。

对整型来说：数据在内存中存放的是补码。

补充：
#include <stdio.h>

int main()
{
    unsigned int y = -10;
    //1000 0000 0000 0000 0000 0000 0000 1010 原
    //1111 1111 1111 1111 1111 1111 1111 0101 反
    //1111 1111 1111 1111 1111 1111 1111 0110 补
    printf("%d\n", y); //-10
    printf("%u\n", y); //4294967286

    //变量如何存？
    //数字需先转为补码，放入空间中，看数据是否有+-号，与变量是否有无符号无关。
    // 
    //变量如何取？
    // 一定要看变量本身的类型，决定是否要看符号位。如果不用，直接将二进制转为十进制。需要的话，则需要转成原码。
    return 0;
}
大小端：

大端：按字节为单位，低权值位数据存储在高地址处，为大端。

小端：按字节为单位，低权值位数据存储在低地址处，为小端。

为什么使用补码？

计算机系统中，数值一律使用补码来表示和存储。因为，使用补码，可以将符号位和数值域一起处理，同时加减法也可一起处理(CPU只有加法器，没有减法器)。另外补码跟原码之间的相互转换，运算过程是一样的，不需要额外的硬件。

取值范围

char
unsigned char: [0,2^8-1]
signed char: [-2^7, 2^7-1] //char
//数据的取值范围，本质是多为比特位所构成的排列组合的数量。

//规律：
//无符号：[0, 2^n-1]
//有符号：[-2^(n-1),2^(n-1)-1]
问题：
//qst1
#include <stdio.h>

int main()
{
    char a[1000];
    for (int i = 0; i < 1000; i++)
    {
        a[i] = -1 - i;        //‘\0’(0)为结束
    }
    printf("%d",strlen(a)); //255
    return 0;
}



//qst2
#include <stdio.h>

int main()
{
    int i = -20;
    unsigned int j = 10;
    printf("%d\n", i+j); //-10
    return 0;
}



//qst3
#include <stdio.h>

int main()
{
    unsigned int i;
    for (i = 0; i >= 0; i++)
    {
        printf("%u\n",i); //死循环
    }
    return 0;
}

1.7 if else组合

基本语法
语法结构：
    //1
    if (表达式)
        语句；

    //2
    if (表达式)
        语句1;
    else
        语句2;

    //3
    if (表达式1)
        语句1；
    else if (表达式2)
        语句2;
    else
        语句3;
补充

1.C语言中’0‘表示假，非’0‘表示为真。

2.if语句的执行，它会先完成表达式中的值，得到逻辑结果，再进行判断。

1.7.1 bool变量与’零值‘进行比较
c语言中是否存在bool类型？

在c99之前，主要c90没有， 目前大部分书中都认为是没有的。但c99中引入了_Bool类型，_Bool就是一个类型，在头文件stdbool.h中，被宏重新写成了bool，为了保证兼容性。

#include <stdio.h>
#include <stdbool.h>

int main()
{
    bool test = true;
    test = false;
    printf("%d\n", sizeof(test));  //1
    return 0;
}



//源码
// stdbool.h
//
//      Copyright (c) Microsoft Corporation. All rights reserved.
//
// The C Standard Library <stdbool.h> header.
//
#ifndef _STDBOOL
#define _STDBOOL

#define __bool_true_false_are_defined 1

#ifndef __cplusplus

#define bool  _Bool
#define false 0
#define true  1

#endif /* __cplusplus */

#endif /* _STDBOOL */
1.7.2 float类型变量与’零值‘进行比较
#include <stdio.h>

int main()
{
    double x = 3.2;
    printf("%.50f\n", x); //3.20000000000000017763568394002504646778106689453125
    return 0;
}
//补充：浮点数在内存中存储不是完整存储的，十进制转化为二进制，可能会有精度损失。
//损失不是一定就减少了，也有可能增多。

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

结论

1.浮点数在进行比较时，不可直接用哦’=='进行比较。

2.浮点数本身有精度损失，导致各种结果可能存在微小的差别。

两个浮点数该怎么比较？
//应该进行范围精度的比较

//1
if ((x - y) > -精度 && (x - y) < 精度)
{
    ;
}

//2 - 简洁版
if (fabs(x - y) < 精度) 
{
    ;
}
//fabs：浮点数求绝对值。
//使用之前需要包含头文件<math.h>

//精度：可用系统精度。
//使用需包含以下头文件

#include <float.h>
DBL_EPSILON //double 最小精度
FLT_EPSILON //float  最小精度
修改后:
#include <stdio.h>
#include <math.h>
#include <float.h>

int main()
{
    double x = 1.0;
    double y = 0.1;
    printf("%.50f\n", x - 0.9);
    printf("%.50f\n", y);

    if (fabs((x - 0.9) - y) < DBL_EPSILON)
    {
        printf("OK\n");
    }
    else
    {
        printf("NO\n");
    }
    return 0;
}


//两个精度的定义
#define DBL_EPSILON      2.2204460492503131e-016 // smallest such that 1.0+DBL_EPSILON != 1.0
#define FLT_EPSILON      1.192092896e-07F        // smallest such that 1.0+FLT_EPSILON != 1.0
float类型变量与’0‘的比较
#include <stdio.h>
#include <float.h>
#include <math.h>

int main()
{
    double x = 0.00000000000000000000001;
    //if(fabs(x-0.0) < DBL_EPSILON){ //1
    //if(fabs(x) < DBL_EPSILON){     //2
    if (x > -DBL_EPSILON && x < DBL_EPSILON) 
        {
            printf("OK\n");
        }
        else
        {
            prinf("NO\n");
        }
    return 0;
}
1.7.3 指针变量与’零值‘进行比较

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

int* p = NULL;
if (p == 0);    if (p != 0);    //1
if (p);            if (!p);        //2
if (p == NULL); if (p != NULL); //3
1.7.4 else与哪个if配对?
#include <stdio.h>

int main()
{
    int a = 1;
    int b = 2;
    if (a == 3)
        if (b == 4)
            printf("1\n");
    else
        printf("2\n");
    return 0;
}



//推荐
#include <stdio.h>

int main()
{
    int a = 1;
    int b = 2;
    if (a == 3)
    {
        {
            if (b == 4)
                printf("1\n");
        }
    }
    else
    {
        printf("2\n");
    }
    return 0;
}
1.8 switch、case、break
语法结构
switch(表达式)

{

        case 常量表达式1: 语句1;break;

        case 常量表达式2: 语句2;break;

        '

        '

        '

        case 常量表达式n: 语句n;break;

        default: 语句n+1;

}

//补充：
#include <stdio.h>

int main()
{
    int x = 1;
    switch (x)
    {
    case x:   //错误！
        printf("OK\n");
        break;
    default:
        printf("NO\n");
        break;
    }
    return 0;
}
1.9 do、while、for
//while
while(表达式){
     循环体语句；
}

//for
for(表达式1;表达式2;表达式3){
     循环体语句;
}

//do-while
do{
   循环体语句；
} 
while(表达式)；
补充：
//三种循环所对应的死循环写法
while(1)
{
    ;
}


for(;;)
{
    ;
}


do
{
    ;
}while(1);
问题：
#include <stdio.h>

int main()
{
    while (1)
    {
        char c = getchar();
        if (c == '#')
        {
            break;
        }
        printf("%c\n", c);  //将\n删去即可
    }
    return 0;
}
1.9.1 break与continue区别
break：

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

continue：

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

1.10 goto关键字
#include <stdio.h>
int main()
{
    int i = 0;
    for (i = 1; i <= 2; i++)
    {
        if (i == 2)
        {
            goto end;
        }
        printf("Hello ");
    }
end: 
    printf("World!\n");
    return 0;
}
1.11 void关键字
void能否定义变量？
#include <stdio.h>

int main()
{
    void a; //err
    return 0;
}
为什么void不能定义变量？

定义变量的本质是开辟空间。void作为空类型，理论上来说是不应该开辟空间的，就算开了空间，也仅作为一个占位符所看待。所以既然无法开辟空间，那么也无法作为正常变量所使用，编译器也就不让它定义变量。

1.11.1 void修饰函数返回值和参数
//s1
#include <stdio.h>

void print()
{
    printf("******\n");
    printf("******\n");
    printf("******\n");
}

int main()
{
    print();
    return 0;
}

//补充：如果定义一个函数或者库函数不需要返回值的话，那就可以写成void。
//如果不写void，自定义函数默认返回值是int。
//如果不写void也会让阅读代码的人产生误解，忘记写了，还是默认int呢？


//s2
#include <stdio.h>

int test1()    //函数默认不需要参数
{
    return 1;
}

int test2(void)//明确表明函数不需要函数
{
    return 1;
}

int main()
{
    printf("%d\n", test1(2));  //依然传入参数，编译器不会警告或报错。
    printf("%d\n", test2(2));  依然传入参数，编译器会警告或报错。
    return 0;
}

//补充：如果一个函数不需要参数，可以将参数列表设置为void,可以将错误明确地发现，也能让阅读代码的人看出意思。
1.11.2 void指针
#include <stdio.h>

int main()
{
    void* p = NULL; //可以
    return 0;
}

void*是指针，能够明确空间大小。

#include <stdio.h>

int main()
{
    void* p = NULL;
    int* a = NULL;
    float* b = NULL;
    p = a;
    p = b; //类型不同，但编译器没报错
    return 0;
}

//总结：void*可用来接受任何指针类型。
1.11.3 void*所定义的指针变量能否进行运算操作
//vs2019
#include <stdio.h>

int main()
{
    void* p = NULL;
    p++;     //err
    p--;     //err
    p += 10; //err
    return 0;
}

//gcc
#include <stdio.h>

int main()
{
    void* p = NULL;    //NULL在数值层面上来说，是0
    p++;
    printf("%d\n", p); //1
    p += 10;
    printf("%d\n", p); //11
    return 0;
}


//为什么不同的平台下，编译器的结果有所不同呢？
//因为大部分的编译器都是标准c,Linux是扩展c，Linuc同时也能保证标准c的运行无误。
1.12 return关键字
#include <stdio.h>

char* show()
{
    char str[] = "hello world";
    return str;
}

int main()
{
    char* a = show();
    printf("%s\n", a); //乱码
    return 0;
}


//return语句不可返回指向栈内存的‘指针’，因为该内存会在函数体结束时自动销毁。
以上代码的解释：

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

调用函数，形成栈帧。

函数返回，释放栈帧。

扩展1：

在计算机中，释放或者说是清除空间是否需要将数据全部清0/1？

清空数据，只需要将该数据设置为无效即可。

扩展2：

临时变量为什么有临时性？

临时变量要在一个变量栈帧结构中开辟空间并保存变量，栈帧结构在函数调用完毕后，要被释放掉。

1.13 const关键字
1.13.1 const修饰变量
#include <stdio.h>

int main()
{
    const int i = 10;
    i = 20;  //报错，变量i不可直接被修改
    return 0;
}
const修饰的变量并不是不可被修改：
#include <stdio.h>

int main()
{
    const int i = 10;
    int* p = (int*)&i;
    *p = 20;
    return 0;
}
const修饰变量的意义：

1.让编译器保护那些不希望被修改的参数，防止无意代码的修改。

2.告诉读代码的人，声明一个参数，是为了告诉用户这个参数的应用目的。

const修饰的变量，不能作为数组定义的一部分：
#include <stdio.h>

int main()
{
    const int n = 10;
    int arr[n]; //报错
    return 0;
}
1.13.2 const修饰一般变量
const int i = 1; 
int const i = 1;
1.13.3 const修饰数组
int const arr[5] = {1,2,3,4,5};
const int a[5] = {1,2,3,4,5};
1.13.4 const修饰指针
const int * p;       //p可变，p指向的对象不可变
int const * p;       //p可变，p指向的对象不可变
int * const p;       //p不可变，p指向的读写可变
const int * const p; //指针p和指向的对象都不可变
1.13.5 const修饰函数的参数
void fun(const int *p)；
1.13.6 const修饰函数的返回值
#include <stdio.h>

const int* test()
{
    static int g_val = 100;
    return &g_val;
}

int main()
{
    int *a = test();
    *a = 200;
    printf("%d\n", *a);
    return 0;
}
1.14 volatile关键字
volatile作用：

编译器对访问votile修饰的变量就不会再进行优化，从而可提供对特殊地址的稳定访问，保持内存可见性。

const volatile int a = 10;

//const负责写，volatile负责读(从内存)，两者并不冲突。
1.15 extern关键字
extern作用：

声明函数或变量。

//test.h

#pragma once
#include <stdio.h>

extern int a;
extern void show();

//test.c
#include "test.h"

int a = 10;

void show()
{
    printf("hello world!");
}

//main.c
#include "test.h"

int main()
{
    show();
    return 0;
}
1.16 struct关键字

空结构体多大：

在VS2013中不可直接定义空结构体，在linux环境下为0字节，不同的编译器，处理的结果不同。

子期cod
关注
  • 28
    点赞
  • 踩
  • 14
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C语言深度解剖-很值得学习
11-19
从给定的文件标题“C语言深度解剖-很值得学习”、描述“C语言深度解剖，很好，很不错的文档，大家共同学习”，以及部分代码内容中，我们可以提炼出以下关于C语言的重要知识点： ### C语言基础类型与关键字解析 在...
深度剖析C语言结构体
08-26
深度剖析C语言结构体 C语言结构体是C语言中的一种数据结构，能够将多个变量组合成一个单元，方便程序员组织和管理数据。今天，我们将深入剖析C语言结构体，探索其实现机理和使用方法。 1. 结构体的定义 在C语言中...
C语言深度剖析-读书简记
hijack00的博客
09-05 2697
陈正冲的《C语言深度剖析. 第2版》这本书确实不错，对C语言中的一些易错和重要的知识点进行了深度剖析，碰巧在网上看到这篇博客，对这本书中的关于C语言的一些易错的和重要的知识点做了一些整理，故转载过来，以便后续查阅。
C语言深度剖析 -- 32个关键字（上）
qq_59702185的博客
01-19 1025
从头开始深度剖析了解C语言的关键字，包括auto、register、static、unsigned、signed、sizeof等等，希望大家一起加油！
C语言深度剖析 -- 32个关键字（下）
qq_59702185的博客
02-10 865
void a;像这样我们定义一个空类型a在vs中是编译不过去的，为什么编译不过去呢？我们来求一下 sizeof(void) 的大小是多少；我们看到在vs中一个void类型是不占用空间的，之前我们说定义变量首先开辟好多少个字节的空间，而void是0个字节，所以就不可以在内存中开辟空间，因此void是不可以定义变量的！！！在Linux中，void也是不可以定义变量的，但是在Linux中 sizeof（int）的大小是1，这是编译器的理解问题；我们只需要知道void不可以定义变量就可以了。
void不是c语言的关键字之一,C语言深度剖析--读书笔记_void 关键字
weixin_42131890的博客
05-19 891
void类型的主要作用：限定函数返回类型，限定函数参数类型1.指针赋值：(1)两种不同类型的指针，不能直接相互赋值(涉及void类型的除外)例1：long *p1;int * p2;p1=p2;警告：从不兼容的指针类型赋值(2)void类型的指针，可以接受任意类型的指针。但是，不能直接把void指针直接赋值给其他例2：void *p1;int *p2;p1=p2; // ok ,没有任何问题p2=...
C语言深度剖析-笔记
weixin_34268753的博客
01-04 88
关键字： C语言关键字32个： 关键字 意 义 auto 声明自动变量，缺省时编译器一般默认为 auto int 声明整型变量 double 声明双精度变...
c语言深度解剖-关键字
m0_37285185的博客
01-05 272
C深度剖析 数据类型 本质：固定内存大小的别名 变量 本质：连续存储空间的别名 #include <stdio.h> ​ typedef int INT32; typedef unsigned char BYTE ; typedef struct _demo { short s; BYTE b1; BYTE b2; INT32 i...
（c语言）-- 深度剖析指针和数组（上）
qq_59552037的博客
10-22 3794
目录一、指针（一）何为指针？==结论：指针就是地址，指针变量是一个变量，变量内部保存指针(地址)数据。==（二）为什么要有指针？***==结论：为了提高CPU寻址效率。==***（三）指针的内存布局（四）指针解引用（五）指针运算1、指针+-整数2、指针-指针3、指针的关系运算（六）野指针1、野指针的成因2、如何规避野指针二、数组（一）数组的概念（二）一维数组1、一维数组的创建和初始化2、一维数组的使用3、一维数组的内存布局4、理解&a[0]和&a的区别5、数组名a做为左值和右值的区别（三）二
C语言深度剖析-C语言逻辑运算（清晰处理与或非逻辑运算）
CC_DD_Chen的博客
05-28 301
C语言逻辑操作符，条件表达式，C语言关键字typedef的使用
c语言错误：向只读位,C语言深度剖析--读书笔记7_const关键字
weixin_29159127的博客
05-21 234
1.const修饰只读变量(1)在GCC中，const修饰的是只读变量。注意，在GCC中，只读变量可以用来定义数组，但是不可以用作case 后面的判断条件。#include "stdio.h"int main(void){int i;const int a=1;const int b=2;const int c=3;const int size=10;int iarr[size]; //没有问题，...
C语言深度剖析
01-30
### C语言深度剖析：关键字详解 #### 引言 C语言作为一门强大的编程语言，其关键字的掌握对于程序员而言至关重要。这些关键字不仅构成了C语言的基础语法框架，而且深刻影响着程序的逻辑流程与数据处理方式。本文将...
Windows图形界面(GUI)-DLG-C/C++ - 日期时间控件(DateTimePicker)
0xCC说逆向
07-21 398
【代码】Windows图形界面(GUI)-DLG-C/C++ - 日期时间控件(DateTimePicker)
C语言 之 理解指针（1）
fallzzzzz的博客
07-20 1131
就是先获取该数组的首元素的地址，从前面我们知道，指针的类型的作用是指针+1 所跳过的字节数，int为整形，大小为4个字节，所以p+1就跳过4个字节，p+2就跳过8个字节，计算机的CPU（中央处理器）在处理数据的时候，需要的数据是在内存中读取的，处理后数据也会放回内存中，如果想对这些空间进行高效的管理，就可以。并且我们知道，数组的元素存放是随着下标增长，内存地址变大的。上面的代码创建了一个整型变量n，因为一个整形的大小是4个字节，所以内存中申请了4个字节，⽤于存放整数10，其中每个字节都有地址。
C++二叉搜索树
Jk_Mr的博客
07-20 1127
树结构是一种重要的数据结构。树是一种非线性的数据结构，它是由n（n>=0）个有限结点组成一个具有层次关系的集合。把它叫做树是因为它看起来像一棵倒挂的树，也就是说它是根朝上，而叶朝下的。
C++笔试强训7
m0_74189279的博客
07-21 972
这意味着编译器会尝试将函数的代码直接插入到每个调用该函数的地方，而不是像通常那样进行函数调用（即，生成调用指令，跳转到函数代码，执行函数体，然后返回）。友元函数是在类外部定义的普通函数，它只能通过传入的参数（如果有的话）来访问类的成员，或者通过类的对象显式地访问（如果该函数设计为接受类的对象作为参数）。函数参数默认值又叫缺省参数，缺省参数必须从右向左开始缺省，必须连续给定缺省值，也就是说，从左到右，一旦遇到一个参数是缺省的，那么之后的参数也必须都是缺省的。指针是类成员函数特有的，用于指向调用该函数的对象。
商品信息管理系统(C语言)
最新发布
zeyeqianli的博客
07-22 325
该案例使用了C语言中最具特色的结构体，将每个商品的所有信息存在结构体中，并且定义一个结构体类型的数组保存所有商品的信息，并且按照模块化的编程思想，将要实现的每个功能编写成独立的函数，这样即方便阅读同时也方便差错修改。该系统的主要功能如下：(1) 登录系统。(2) 创建商品信息。(3) 打印商品信息。(4) 查询商品信息。(5) 修改商品信息。(6) 删除商品信息。(7) 商品价格排名显示。(8) 退出系统。
C语言深度剖析：关键字详解
"C语言深度剖析.pdf" 这本PDF文件详细阐述了C语言的关键概念和语法，旨在帮助读者深入理解这门编程语言。作者通过轻松幽默的叙述方式，讲解了C语言中的关键字及其用法，适合面试准备和进阶学习。 首先，书中提到了...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值