c 1

main函数作用

main函数是程序的入口点，操作系统运行程序的时候从main函数开始执行。

一个程序只能有一个main函数。

main函数2种写法

1：

int main()
{
    return 0;
}

2：

void main()
{
    
}

# include 包含

使用工具箱（包含头文件），在每一个被导入的工具箱中都定义了一系列相关的、已经写好的功能函数。如果想使用：

导入
使用

工具箱分为2种： C语言自带的（#include<>，告诉编译器去系统目录下找）、自定义（#include " "，告诉编译器去当前目录下找）

对文件进行编译

首先安装gcc编译器
把文件进行预处理后合成一个文件的c语言代码
那c语言代码转换成汇编语言
把汇编文件代码转换成机器语言的二进制文件
对二进制文件进行链接生成exe文件

// 预处理文件
gcc -E index.c -o index.i

// 编译文件
gcc -S index.i -o index.s

// 把汇编代码转成二进制文件
gcc -c index.s -o index.o

//  对二进制文件进行链接
gcc index.o -o index.exe

变量

程序用来处理数据。待处理的数据要能够保存，用变量来保存数据。

变量其实就是一块内存空间，这块内存空间中的存储的值可以修改的。

变量：变量名字变量的地址变量的空间大小。

int a = 10;    // 分配空间，把10存储到a这个空间中。 pringf("%p", &a);
int b = 20;
int c = a + b;

程序结束之后， a b c 三个变量的数据就不存在了。如果想让数据持久化的存储，那么就需要把a b c 存储到硬盘上，文件或者数据库中。

变量用来存储程序运行过程中所需要的临时数据。

变量名命名规则

标识符不能是关键字
标识符只能由字母、数字、下划线组成
第一个字符必须为字母或下划线
标识符中字母区分大小写

变量名定义要求：变量名一定要见名知意。

变量名规范：

小驼峰法：变量由多个单词构成则首个单词小写，后面单词首字母大写，如果一个单词则小写。 userNameAge
大驼峰法：变量由多个单词构成则所有单词首个字母大写。如果一个单词，则字母大写。 UserNameAge
小写+下划线：单词之间使用下划线相连。C语言中该命名方法居多。 user_name_age

在C语言，用小写+下划线最多。

变量命名规则

变量的作用就是临时存储程序运行过程中需要的数据。

变量：变量名、变量地址、变量值，在程序中可以通过变量名、地址来操作变量（读写变量）。

int a = 10; // int 类型、a变量名、10值

变量类型分类

基本数据类型，编译器内置的数据类型 int ，同一个系统同一个编译器大小是一样的。
1. 整型（short、int、long、longlong）
2. 浮点型
3. 字符型
自定义数据类型，大小和定义有关系
指针类型。基本类型的指针、自定义类型的指针。

整型

每一种类型的：空间大小、取值范围、该类型输出、类型的输入、有符号类型和无符号类型

只有整数类型才有符号和无符号之分，小数不分。

signed int a = 100; // 有符号的变量，既可以存储正数、也可以存储负数
unsigned int b = 100; //无符号的最小值 0

示例

#if 1 
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <limits.h>

// 1、short 类型的输入和输出（短整型）
void test01() {
    // 1.1 无符号、有符号 short 类型的输入和输出
    short s = 100;
    printf("有符号short: %hd\n", s);

    unsigned short us = 100;
    printf("无符号 short：%hu\n", us);

    // 1.2 short 类型占用的内存大小 sizeof
    int short_size = sizeof(short);
    printf("short 类型占用的内存大小是： %d\n", short_size);
    printf("short 类型占用的内存大小是： %d\n", sizeof(short));
    printf("unsigned short 类型占用的内存大小是： %d\n", sizeof(unsigned short));

    // 1.3 short 类型和 unsigned short类型的取值范围
    printf("short 类型最小值是： %hd，最大值是：%hd\n", SHRT_MAX, SHRT_MIN);
    printf("unsigned short 类型最小值是： 0，最大值是：%hu\n", USHRT_MAX);

    // 1.4 short 类型输入操作 scanf
    short short_number = 0;
    printf("请输入一个short类型的数字：");
    // %hd 表示按照 short 类型输入， &short_number 表示键盘输入数据之后，数据存储到内存中哪个位置
    scanf("%hd", &short_number);    // 阻塞等待
    printf("您输入的 short 类型的值是： %hd\n", short_number);

    unsigned short ushort_number = 0;
    printf("请输入一个 unsigned short 类型的数字：");
    scanf("%hu", &ushort_number);
    printf("你输入的unsigned short 类型的值是：%hu\n", ushort_number);


}
// 2、int 类型的输入和输出（整型）
void test02() {
    // 2.1 int 类型和 unsigned int 类型输入和输出
    int i = 100;
    printf("i = %d\n", i);
    unsigned int ui = 666;
    printf("ui = %u\n", ui);

    // 2.2 int 类型占用的内存大小
    printf("int 类型占用的内存大小：%d\n", sizeof(int));
    printf("unsigned int 类型占用的内存大小：%d\n", sizeof(unsigned int));

    // 2.3 有符号、无符号类型取值范围
    printf("int 类型的最小值：%d， 最大值：%d\n", INT_MIN, INT_MAX);
    printf("unsigned int 类型的最小值：0， 最大值：%u\n", UINT_MAX);

    // 2.4 int类型 变量输入
    int int_number = 0;
    printf("请输入 int 类型的值：");
    scanf("%d", &int_number);
    printf("您输入的 int 类型的值是：%d\n", int_number);

    unsigned int un_int_bumber = 0;
    printf("请输入 unsigned int 类型的值：");
    scanf("%u", &un_int_bumber);
    printf("您输入的 unsigned int 类型的值是%u\n", un_int_bumber);
}
// 3、long 类型的输入和输出
void test03() {
    // 3.1 long 类型和unsigned long 类型输出
    long l = 888;
    printf("l = %ld\n", l);
    unsigned long ul = 888;
    printf("ul = %ul\n", ul);
    
    // 3.2 long 类型占用的内存大小
    // long 的大小不能比 int 小
    // gcc 编译器 long 类型占8个字节
    printf("long 类型占用的内存大小是：%d\n", sizeof(long));
    printf("unsigned long 类型占用的内存大小是：%d\n", sizeof(unsigned long));

    //3.3 long 类型的取值范围
    printf("long类型的最小值:%ld， 最大值:%ld \n", LONG_MIN, LONG_MAX);
    printf("long类型的最小值:0， 最大值:%ul \n", ULONG_MAX);

    // 3.4 long输入
    long long_number = 0;
    printf("请输入long类型的值");
    scanf("%ld", &long_number);
    printf("您输入的long类型的值为：%ld\n", long_number);

    unsigned long un_long_number = 0;
    printf("请输入unsigned long类型的值");
    scanf("%lu", &un_long_number);
    printf("您输入的unsigned long类型的值为：%lu\n", un_long_number);


}
// 4、long long 类型的输入和输出
void test04() {
    // 3.1 long long 类型和unsigned long long 类型输出
    long long ll = 888;
    printf("l = %lld\n", ll);
    unsigned long long ull = 888;
    printf("ull = %llu\n", ull);

    // 3.2 long long 类型占用的内存大小
    printf("long long 类型占用的内存大小是：%d\n", sizeof(long long));
    printf("unsigned long long 类型占用的内存大小是：%d\n", sizeof(unsigned long long));

    //3.3 long 类型的取值范围
    printf("long long类型的最小值:%lld， 最大值:%lld \n", LLONG_MIN, LLONG_MAX);
    printf("long long类型的最小值:0， 最大值:%llu \n", ULLONG_MAX);

    // 3.4 long输入
    long long long_long_number = 0;
    printf("请输入long long类型的值");
    scanf("%lld", &long_long_number);
    printf("您输入的long long类型的值为：%lld\n", long_long_number);

    unsigned long long un_long_long_number = 0;
    printf("请输入unsigned long类型的值");
    scanf("%llu", &un_long_long_number);
    printf("您输入的unsigned long类型的值为：%llu\n", un_long_long_number);


}

// short < int < long < long long

int main(int argec, char* argv[])
{

    //test01();
    //test02();
    // test03();
    test04();
    system("pause");
    return 0;
}
#endif

字符串

#if 1
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <limits.h>
#include <ctype.h>

// 1、字符语法（字符变量的定义、输入和输出、字符的内存大小、字符的存储原理、字符取值范围）
void test01() {
    // 1.1 字符变量的定义、输出
    char c1 = "a";
    char c2 = "1";

    printf("c1 = %c\n", c1);
    printf("c2 = %c\n", c2);

    // 1.2 字符占用内存大小
    printf("char 类型内存大小： %d\n", sizeof(char));

    // 1.3 字符存储、字符在存储的时候实际存储的是一个数字。 ascii 码表 
    printf("c1 = %d\n", c1);
    char c3 = 97;
    printf("c3 = %c\n", c3);

    // 1.4 char 类型取值范围
    printf("char 的最小值： %d, 最大值：%d\n", CHAR_MIN, CHAR_MAX);
    printf("unsigned char 的最小值： 0, 最大值：%d\n", UCHAR_MAX);

    // 1.5 char 输入
    char c_text = "";
    printf("请输入char类型的值：");
    scanf("%c", &c_text);
    printf("您输入的char类型的值为：%c", c_text);


}
// 2、字符简单操作
void test02(){
    char c1 = 'a';
    char c2 = 'B';

    // 如果需要使用字符处理函数（功能），需要导入文件 ctype.h
    // 2.1 把字符转换成大写
    char c3 = toupper(c1);
    printf("c3 = % c, c1 = % c\n", c3, c1);

    // 2.2 把字符转换成小写
    char c4 = tolower(c2);
    printf("c4 = %c, c2 = %c\n", c4, c2);
    // 2.3 把字符转换成 ascii 码值
    int ascii_val = toascii(c1);
    printf("ascii_val: %d\n", ascii_val);
}

// 3、练习：从键盘输入任意一个字母，将其转换为大写并输出
void test03() {
    printf("输入任意一个字母");
    char c;
    scanf("%c", &c);
    
    printf("您输入的字母是：%c\n", toupper(c));
}

// 4、转义字符
void test04() {

    // 1、\a 警报
    printf("123\a4\n");

    // 2、\b 退格
    printf("123\b4\n");

    // 3、 \n 换行

    // 4、制表符
    printf("123\t4\n");

    // 5、 "\\" 输出一个 "\" 转义斜杠
    printf("\\t\n");

    // 6、 \" 输出一个双引号
    printf("\"\n");

    // 7、%% %d %c %hd %u 占位符
    printf("99.9%%\n");

    // 8、 \0dd
    printf("\022\n");
    printf("\x22\n");


}
//

int main(int argec, char* argv[])
{

    //test01();
    // test02();
    // test03();
    test04();
    system("pause");
    return 0;
}
#endif

进制转换

十进制：逢十进一， 0-9
二进制：逢二进一， 0-1
八进制：逢八进一， 0-7
十六进制：逢十六进一， 0-F

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

// 1. 进制的赋值
void test01() {
    // 程序不支持二进制父子
    // 程序不支持二进制输出

    int a = 12;    // 十进制        12
    int b = 012;    // 八进制        10    oct
    int c = 0x12;    // 十六进制    18    hex

    printf("a: %d\n", a);
    printf("b: %d\n", b);
    printf("b: %d\n", c);

    printf("a: %d\n", a);
    printf("b: 0%o\n", a);
    printf("b: 0x%x\n", a);
}

void test02() {
    int n = 38;

    // 申请指定大小的内存空间
    // ={0} 表示将128字节空间全部清空
    char bin[128] = {0};

    // 第一个值表示要进行进制转换的值
    // 第二个值表示要进行进制转换完毕之后，将结果存储到哪个内存中
    // 第三个值表示要进行二进制转换，八进制，十六进制，32进制.... 2^n次方
    _ltoa(n, bin, 2);
    printf("%s\n", bin);

    char oct[128] = { 0 };
    _ltoa(n, oct, 8);
    printf("%s\n", oct);

    char hex[256] = { 0 };
    _ltoa(n, hex, 16);
    printf("%s\n", hex);
}

int main(int argec, char* argv[])
{

    //test01();
    test02();
    system("pause");
    return 0;
}
#endif

浮点类型

float 精度：6-7，6位准确，78位不保证准确

double 精度：15-16，15位准确，16不保证准确

float 和 double 取值范围很大，但是精度不高，当输入一个浮点数时，编译器会将其精确到某一个近似值上。

#if 1 
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <float.h>


// 1. 浮点类型语法(float、double)
void test01() {

    // 浮点类型的定义和输出（默认输出小数点后6位）
    float f1 = 3.14f;
    double d1 = 3.14;
    printf("f1: %f \n", f1);    // f1: 3.140000
    printf("d1: %lf \n", d1);    // d1: 3.140000
    printf("f1: %.8f \n", f1);    // f1: 3.14000010
    printf("d1: %.8lf \n", d1);    // d1: 3.14000000
    
    // float(单精度)类型精确的位数：6-7位，精确7位不保证一定准确，精确到6位保证绝对准确
    // double(双精度)类型精确的位数：15-16位，精确到16位不保证一定准确，精确到15位肯定准确

    // 1.2 浮点类型占用的内存大小
    printf("float 内存大小：%d\n", sizeof(float));    //float 内存大小：4
    printf("double 内存大小：%d\n", sizeof(double));    //double 内存大小：8

    // 浮点类型输出
    float f = 0.0f;
    printf("请输入一个小数：");
    scanf("%f", &f);
    printf("f: %.2f\n", f);

    double d = 0.0;
    printf("请输入一个小数：");
    scanf("%lf", &d);
    printf("d: %.2lf\n", d);

}

// 2. 浮点类型的赋值（科学技术法）
void test02() {
    float f1 = 3.14e3f;    // 3.14 * 10^3
    float f2 = 3.14e+3f;    // 3.14 * 10^3
    float f3 = 3.14e-3f;
    printf("%f %f %f \n", f1, f2, f3);

    double d = 3.14e3;
    printf("%lf\n", d);
}

// 3. 浮点类型取值范围
void test03() {
    printf("float 类型的最小值：%f，最大值：%f \n", FLT_MIN, FLT_MAX);
    // float 类型的最小值：0.000000，最大值：340282346638528859811704183484516925440.000000

    printf("double 类型的最小值：%lf, 最大值：%lf\n", DBL_MIN, DBL_MAX);
}    // double 类型的最小值：0.000000, 最大值：179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368.000000

int main(int argec, char* argv[])
{

    // test01();
    // test02();
    test03();
    system("pause");
    return 0;
}
#endif

数值溢出

整型溢出：

当无符号类型，达到上限的话，值会回到原点。如果达到下限，再进行计算，值回到最大值。
当有符号类型，达到上限再+1的话，值会回到最小值。如果达到下限，再减一，值会回到最大值。（编译器行为，c语言只规定无符号类型溢出的规则，对于有符号类型并没有做出规定，当有符号数据溢出时，结果undefined未定义）

浮点数溢出：

当浮点数上溢出，编译器会用一个词表示无穷大（vs inf）。
当浮点数下溢出，指数会向尾部部分借位，尾数减少一位。

类型转换

C语言允许不同数据类型之间进行类型转换。类型转换分为：

自动类型转换。
强制类型转换。

自动类型转换：

1.运算中类型转换：如果两个不同类型之间数据运算，先要将其转换为相同类型，再进行计算。

两个 float 类型会转换为 double 类型再进行运算，结果也是 double 类型（不同编译器可能有不同规则）
long 类型和 int 类型运算，一般会将其转换为 long 类型，再进行运算，结果是 long 类型。
这些转换由系统自动完成。

2.赋值中的类型转换：把等号右侧的值转换为等号左侧值的类型。

浮点类型转换为整型，会舍弃小数部分。整型转换为浮点类型，值不变，只是将值的形式改成浮点形式。
float 转换为 double 类型，在尾部加 0 变成 double 类型转换为 float 类型，舍弃部分精度。
char 类型转换为 int 类型，一般任保留原值（ASCII）。 int 转换为 char 类型，高位字节舍弃。
int 类型转换为 long 类型，直接转换。 long 类型转换为 int 类型则舍弃高位字节。
int long 转换为 unsigned 类型，

posted @ 2024-07-18 10:31 陨落&新生阅读(43) 评论(0) 编辑收藏举报

刷新页面返回顶部

不积跬步,无以至千里.不积小流,无以成江海

在乎对自己好的人，不要在乎那些不重要的人，因为他们在你的生活只是一个过客。珍惜对自己重要的人，不要伤害那些在乎自己的人。

c 1