C语言基础（一）

沐风听雨_A

已于 2024-08-17 21:20:49 修改

阅读量387

点赞数 9

文章标签： c语言 c++ 开发语言

于 2024-08-17 21:19:00 首次发布

本文链接：https://blog.csdn.net/wehpd/article/details/141286441

版权

C语言的基本数据类型及其取值范围因编译器和目标平台（如32位或64位系统）的不同而有所差异。

1、整型（Integer Types）

char：字符型，通常用于存储单个字符。char可以是有符号的（signed char），可以存储的值的范围是-128到127（如果char是8位的）。char也可以是无符号的（unsigned char），此时其值的范围是0到255。char实际上是一个小的整型，用于存储字符的ASCII码或Unicode码。

signed char：明确指定为有符号的字符型，取值范围通常是-128到127（如果char是8位的）。

unsigned char：明确指定为无符号的字符型，取值范围通常是0到255（如果char是8位的）。

short 或 short int：短整型，取值范围通常是-32,768到32,767（如果short是16位的）。

unsigned short 或 unsigned short int：无符号短整型，取值范围通常是0到65,535（如果short是16位的）。

int：基本整型，取值范围取决于编译器和目标平台。在32位系统上，int通常是32位的，取值范围大约是-2,147,483,648到2,147,483,647。

unsigned int：无符号基本整型，取值范围也取决于编译器和目标平台。在32位系统上，取值范围通常是0到4,294,967,295。

long 或 long int：长整型，取值范围也取决于编译器和目标平台。在32位系统上，long可能是32位的，与int相同；但在64位系统上，它通常是64位的。

unsigned long 或 unsigned long int：无符号长整型，取值范围同样取决于编译器和目标平台。
long long 或 long long int（C99及之后）：长长整型，取值范围至少是-263到263-1（如果long long是64位的）。

unsigned long long 或 unsigned long long int（C99及之后）：无符号长长整型，取值范围至少是0到2^64-1（如果long long是64位的）。

2、浮点型（Floating-Point Types）

float：单精度浮点型，能够表示的范围大约是1.4E-45到3.4E+38，精度大约是7位十进制数字。

double：双精度浮点型，能够表示的范围大约是4.9E-324到1.8E+308，精度大约是15到17位十进制数字。

long double：扩展精度浮点型，其范围和精度至少与double相同，但可能更大，这取决于具体的实现。

3、_Bool 或 bool（C99及之后）

_Bool是C99标准中引入的，用于表示布尔值（真或假）。标准库头文件<stdbool.h>通常定义了一个宏bool作为_Bool的别名，并定义了true和false两个宏来分别表示真和假。在实践中，通常使用bool而不是_Bool。

4、枚举类型（Enum Types）

枚举不是基本数据类型，它是用户定义的类型，基于整数。枚举允许程序员为整数常量指定更易读的名字。枚举类型的定义通常使用enum关键字。

5、void

void是一种特殊的数据类型，表示“无类型”。它通常用于函数返回类型，表示该函数不返回任何值；也用于指针类型，表示该指针不指向任何类型的数据。枚举和void类型，通常不被归类为基本数据类型，因为它们具有特殊的用途和行为。

测试代码1：

#include <stdio.h>  
#include <string.h> 
int main() {  
    // 定义并初始化基本类型变量  
    int intVar = 10;  
    short shortVar = 20;  
    long longVar = 3000000L; // L后缀  
    long long longLongVar = 1234567890123456789LL; // LL后缀  
  
    float floatVar = 3.14f;  
    double doubleVar = 3.141592653589793;  
    // 在一些系统中，需要显式指定long double的字面量后缀。
    char charVar = 'A';  
    // 打印变量的值。 
    printf("intVar: %d\n", intVar);  
    printf("shortVar: %d\n", shortVar);  
    printf("longVar: %ld\n", longVar);  
    printf("longLongVar: %lld\n", longLongVar);  
    printf("floatVar: %.2f\n", floatVar);  
    printf("doubleVar: %.10f\n", doubleVar);  
    printf("charVar: %c\n", charVar);  
    return 0;  
}

运行结果如下：

测试代码2：

#include <stdio.h>  
// 定义一个枚举类型  
enum Color {RED, GREEN, BLUE};  
  
int main() {  
    // 整型变量  
    int myInt = 10;  
    printf("整型变量: %d\n", myInt);  
    // 字符型变量  
    char myChar = 'A';  
    printf("字符型变量: %c\n", myChar);  
    // 浮点型变量  
    float myFloat = 3.14f;  
    double myDouble = 3.141592653589793;  
    printf("浮点型变量(float): %f\n", myFloat);  
    printf("浮点型变量(double): %lf\n", myDouble);  
    // 枚举型变量  
    enum Color myColor = RED;  
    printf("枚举型变量: %d\n", myColor); // 注意枚举类型在打印时通常作为整数处理  
    return 0;  
}

运行结果如下：

...........................................................................................................................................................

获取变量的存储空间：

测试代码：

#include <stdio.h>  
int main() {  
    int a;  
    char b;  
    double c;  
    printf("Size of int: %zu bytes\n", sizeof(a));  
    printf("Size of char: %zu bytes\n", sizeof(b));  
    printf("Size of double: %zu bytes\n", sizeof(c));  
    // 也可以查询类型本身  
    printf("Size of int type: %zu bytes\n", sizeof(int));  
    printf("Size of char type: %zu bytes\n", sizeof(char));  
    printf("Size of double type: %zu bytes\n", sizeof(double));  
    return 0;  
}

运行结果如下：

..........................................................................................................................................................

变量与常量的区别：

测试代码：

#include <stdio.h>  
int main() {  
    // 定义一个整型常量（使用const关键字）  
    const int MAX_VALUE = 100;  
    // 尝试修改常量的值（编译错误）  
    // MAX_VALUE = 200; // 无法通过编译  
  
    // 定义一个整型变量  
    int counter = 0;  
    // 打印变量的初始值  
    printf("变量的初始值: %d\n", counter);  
    // 修改变量的值  
    counter = 50;  
    // 打印变量修改后的值  
    printf("变量修改后的值: %d\n", counter);  
    // 用#define定义的宏常量
    #define PI 3.14159  
    // 使用PI常量  
    double radius = 5.0;  
    double area = PI * radius * radius;  
  
    // 计算得到的圆的面积  
    printf("圆的面积: %.2f\n", area);  
    return 0;  
}

运行结果如下：

...........................................................................................................................................................

自动类型转换：

测试代码1：

#include <stdio.h>  
int main() {  
    // 整型之间的自动类型转换（较小类型提升到较大类型）  
    short int shortVar = 1000;  
    int intVar = shortVar + 1; // shortVar会被自动提升为int类型，然后与1相加  
    printf("intVar = %d\n", intVar);  
    // 字符型到整型的自动类型转换  
    char charVar = 'A';  
    int intFromChar = charVar + 1; // charVar会被自动提升为int，然后与1相加  
    printf("intFromChar = %d (character '%c')\n", intFromChar, intFromChar);  
    // 浮点型与整型之间的自动类型转换（整型会被提升为浮点型）  
    float floatVar = 5.0f;  
    int intVar2 = 3;  
    float floatResult = floatVar + intVar2; // intVar2会被自动提升为float，然后与floatVar相加  
    printf("floatResult = %.2f\n", floatResult);  
    // 枚举类型到整型的自动类型转换（枚举值在大多数情况下被视为整数）  
    enum Color { RED, GREEN, BLUE };  
    enum Color colorVar = RED;  
    int intFromEnum = colorVar; // 枚举值被隐式地转换为整数  
    printf("intFromEnum = %d\n", intFromEnum);  
    // 自动类型转换不会发生在不相关或不兼容的类型之间，  
    // 比如不能直接将一个结构体或联合体赋值给一个整型变量而不进行显式转换（会导致编译错误）。  
    return 0;  
}

运行结果如下：

测试代码2：

#include <stdio.h>  
int main() {  
    // 整型之间的自动类型转换  
    short int a = 10;  
    int b = a; // 自动从short int转换为int  
    printf("a = %d, b = %d\n", a, b);  
    // 字符型到整型的自动类型转换  
    char c = 'A';  
    int d = c; // 自动从char转换为int  
    printf("c = %c, d = %d\n", c, d); // 注意：%d用于打印整数值  
  
    // 浮点型到整型的自动类型转换（
    float e = 3.14f;  
    int f = e; // 自动从float转换为int
    printf("e = %.2f, f = %d\n", e, f);  
  
    // 整数到浮点型的自动类型转换  
    int g = 5;  
    float h = g; // 自动从int转换为float  
    printf("g = %d, h = %.2f\n", g, h);  
    // 窄的枚举类型到宽的整型的自动类型转换  
    enum Color {RED, GREEN, BLUE};  
    enum Color myColor = RED;  
    int colorAsInt = myColor; // 枚举类型通常会被编译器视为整数类型
    printf("myColor = %d, colorAsInt = %d\n", myColor, colorAsInt);  
    // 字符串常量不是数据类型转换的一部分，而是作为字符数组处理。  
    return 0;  
}

运行结果如下：

...........................................................................................................................................................

强制类型转换：

测试代码：

#include <stdio.h>  
int main() {  
    // 整型之间的强制类型转换  
    short int a = 10000; // 可能会发生溢出，因为short int的范围可能不足以存储10000  
    int b = (int)a; // 强制从short int转换为int  
    printf("a (as short int) = %d, b (as int) = %d\n", a, b);  
    // 字符型到整型的强制类型转换  
    char c = 'A';  
    int d = (int)c; // 强制从char转换为int  
    printf("c (as char) = %c, d (as int) = %d\n", c, d);  
    // 浮点型到整型的强制类型转换
    float e = 3.14159f;  
    int f = (int)e; // 强制从float转换为int，丢失小数部分  
    printf("e (as float) = %.2f, f (as int) = %d\n", e, f);  
    // 整数到浮点型的强制类型转换  
    int g = 5;  
    float h = (float)g; // 强制从int转换为float  
    printf("g (as int) = %d, h (as float) = %.2f\n", g, h);  
    // 枚举类型到整型的强制类型转换（枚举通常隐式地作为整数处理）  
    enum Color {RED, GREEN, BLUE};  
    enum Color myColor = RED;  
    int colorAsInt = (int)myColor; // 枚举值在大多数情况下是以整数形式存在的  
    printf("myColor (as enum) = %d, colorAsInt (as int) = %d\n", myColor, colorAsInt);  
    // 浮点型之间的强制类型转换（会改变精度）  
    double i = 3.141592653589793;  
    float j = (float)i; // 强制从double转换为float，丢失精度  
    printf("i (as double) = %.15f, j (as float) = %.5f\n", i, j);  
    // 指针类型的强制类型转换（谨用）  
    int* ptrToInt = NULL;  
    void* ptrToVoid = (void*)ptrToInt; // 将int*转换为void*  
    // 将void*转换回具体类型的指针时，需要强制类型转换  
    int* ptrToIntAgain = (int*)ptrToVoid;  
    return 0;  
}

运行结果如下：