C/C++ 变量

概念

声明

声明仅告诉编译器变量名称和类型, 不分配内存

变量可以声明多次

int i;

typedef int INT;

struct Node;

extern

extern int var;

extern声明变量, 表示其已定义, 提示编译器遇到它时需在其它文件中寻找

定义

定义是给变量分配内存, 可以为变量赋初值

变量只能定义一次

C/C++中变量声明和定义区别并不大, 往往同时发生

// 声明 + 定义, 变量名为 value, 类型为 int, 分配 4 字节内存(不同编译器会有差异)
int value;

// 声明 + 定义
struct Node {
    int left;
    int right;
}; 

// 若给变量赋值, 即使有extern也是定义
extern int b = 10;

类型

全局变量

int globalValue = 0xFF;

从静态存储区域分配, 作用域为全局

对于多个源文件, 全局变量只需在一个文件中定义, 其他文件中通过extern声明

生命周期与整个程序同在, 从程序开始到结束一直起作用

全局使用

示例, 使用全局变量

// file_1.c
int globalValue = 0xFF; 

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

extern int globalValue; 

int main() {
    printf("%d\n", globalValue);
    return 0;
}

全局静态变量

static int globalValue = 0xFF;

从静态存储区域分配, 作用域只在定义它的源文件内, 其他源文件不能使用

生命周期与整个程序同在, 从程序开始到结束一直起作用

限制作用域

全局static变量只在定义它的文件内可见, 避免与其他文件中同名变量冲突

// file_1.c
// 只能在当前文件访问
static int sharedValue = 10; 

void modifyValue() {
    sharedValue++;
}

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

// 无法访问, 因为sharedValue是static变量
extern int sharedValue; 

int main() {
    printf("%d\n", sharedValue);
    return 0;
}

局部变量

示例, 调用局部变量

void Func() {
    int i = 3;
}

// 错误
printf("%d\n", i);

从栈上分配, 作用域只在局部函数内, 出了函数局部变量就不再起作用

生命周期只和该函数同在

局部静态变量

void Func() {
    static int i = 3;
}

// 错误
printf("%d\n", i);

从静态存储区域分配, 作用域只在定义它的函数内可见, 出了该函数就不可见

生命周期与整个程序同在, 从程序开始到结束一直起作用

保持状态

局部static变量在函数内部定义, 能够在多次调用之间保持其值, 它只在第一次调用时初始化, 之后调用将使用该变量上一个值

示例, 打印static变量

#include <stdio.h>

void Counter() {
    // 初始化一次
    static int count = 0;
    // 会记录上次值
    count++;
    printf("Count: %d\n", count);
}

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

#include <stdio.h>
#include <malloc.h>

// 全局区 全局变量
int gValueA = 1;
int gValueB = 2;

// 全局区 静态变量
static int sValueA = 3;
static int sValueB = 4;

// 全局区 全局常变量
const int gCValueA = 5;
const int gCValueB = 6;

// 全局区 字符串常量
const char *s1 = "Hello World";

void test() {
    // 全局区 局部静态变量
    static int sA = 3;
    static int sB = 4;
    printf("局部静态变量 &sA = %p\n", &sA);
    printf("局部静态变量 &sB = %p\n", &sB);

    printf("-----------------栈区-----------------\n");
    // 栈区 局部变量
    int a = 1;
    int b = 2;
    printf("局部变量 &a = %p\n", &a);
    printf("局部变量 &b = %p\n", &b);

    const int cA = 3;
    const int cB = 4;
    printf("局部常量 &cA = %p\n", &cA);
    printf("局部常量 &cB = %p\n", &cB);

    printf("-----------------堆区-----------------\n");
    // 堆区
    char *p[3] = {NULL};
    for (int i = 0; i < 3; i++) {
        p[i] = (char *)malloc(4 * sizeof(char));
        printf("&p[%d] = %p\n", i, &p[i]);

        free(p[i]);
        p[i] = NULL;
    }
}

int main(void){
    printf("-----------------全局区-----------------\n");
    printf("全局变量 &gValueA = %p\n", &gValueA);
    printf("全局变量 &gValueB = %p\n", &gValueB);
    printf("全局静态变量 &sValueA = %p\n", &sValueA);
    printf("全局静态变量 &sValueB = %p\n", &sValueB);
    printf("全局常量 &gCValueA = %p\n", &gCValueA);
    printf("全局常量 &gCValueB = %p\n", &gCValueB);
    printf("全局字符串常量 &s = %p\n", &s1);

    test();
    return 0;
}

数据类型

整形

无符号类型

unsigned int

无符号整型, 长32位

unsigned int

uint32_t

// sizeof(uint32_t) = 32

unsigned long long

unsigned long long

unsigned long long int

uint64_t

// sizeof(uint64_t) = 64

unsigned char

unsigned char

uint8_t

// sizeof(uint8_t) = 8

浮点型

float

大小为4字节, 32位

double

大小为8字节, 64位

判断相等

int a;
double b;

// 向下取整
printf("%.0lf\n", floor(a * b * 0.1));

相除余数

double a, b;

scanf("%lf%lf", &a, &b);

int k = a / b;
double r = a - k * b;

printf("%g", r);

上篇数据结构题

下篇makefile使用