c/c++：数据类型，常量变量，标识符，有符号整型，无符号unsigned，字符类型，字符串类型，实数类型，浮点型，科学计数法

2022找工作是学历、能力和运气的超强结合体，遇到寒冬，大厂不招人，此时学会c++的话，
我所知道的周边的会c++的同学，可手握10多个offer，随心所欲，而找啥算法岗的，基本gg
提示：系列c++学习的基础和高阶知识，用于公司生产实践中，实实在在的公司部署产品要用的，因为c++速度快，
而java和Python速度慢，自然往硬件里面部署算法啥的，都得用c++或者c，因此本科学的c很重要，后来的Python或者java就没有那么重要了，
c/c++系列文章：
【1】c++：c语言优缺点，visual studio2019如何新建项目，写hello world程序
【2】c/c++:gcc安装，gcc编译hello world文件，system函数调用系统命令，sleep函数
【3】linux下gcc的编译过程和功能，预处理，编译，汇编，链接，.c预处理为.i文件.s文件.o文件.exe文件
【4】c/c++：windows平台下依赖的动态库，c底层是汇编语言，程序断点调试，反汇编，vs快捷键

文章目录

• c/c++：数据类型，常量变量，标识符，有符号整型，无符号unsigned，字符类型，字符串类型，实数类型，浮点型，科学计数法
• • @[TOC](文章目录)
• c/c++：常量，不会变化的数据
• 变量，会变化的量，可以重新定义
• 标识符命名规则
• 无符号整型unsigned
• 字符类型，字符串类型
• 实数类型，浮点型
• 总结

c/c++：常量，不会变化的数据

字符串常量"hello"
字符常量’a’
整型常量10
浮点型常量3.14
宏定义常量#define PI 3.14

#define PI 3.14
定义关键字 宏常量名 宏值

定义关键字 宏常量名 宏值
屁股是没有分好；的哦

这种宏定义常量和普通常量的区别是啥呢？

宏：直接用原始值【推荐宏定义定义常量哦】
常量，把数值放入内存的

被该关键字修饰的变量是只读变量，那就是常量呗

const int a=10;
//被该关键字修饰的变量是只读变量，那就是常量呗

咱们最推荐的就是用宏定义常量哦

#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#include<math.h>
#include<time.h>//很多库后续调用各种函数都需要用的//定义常量
#define PI 3.14void f1(void)
{//圆的面积s=pi*r*r//圆的周长c=2*pi*rint r = 3;//变量半径float s = PI * r * r;//浮点数float c = 2 * PI  * r;//浮点数printf("r=3的圆面积：%f,周长为%f\\n", s, c);
}int main(void)
{f1();system("pause");return 0;
}

.kf
指定小数点后面保留k位

这好说

当预处理阶段时，代码会将宏常量替换哦
宏定义常量不能加；

否则它就这样替换了

//定义常量
#define PI 3.14;void f1(void)
{//圆的面积s=pi*r*r//圆的周长c=2*pi*rint r = 3;//变量半径float s = 3.14; * r * r;//浮点数

这个3.14;替代pi之后
你后面的rr就废了
代码结束，不可哦

#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#include<math.h>
#include<time.h>//很多库后续调用各种函数都需要用的//定义常量
#define PI 3.14void f1(void)
{//圆的面积s=pi*r*r//圆的周长c=2*pi*rint r = 3;//变量半径const int d = 6;//常量，直径float s = PI * r * r;//浮点数double s2 = PI * d * d;//浮点数float c = 2 * PI  * r;//浮点数printf("r=3的圆面积：%.2f,周长为%.2f\\n", s, c);printf("d=6的圆面积：%.2f\\n", s2);
}int main(void)
{f1();system("pause");return 0;
}

你还可以通过const int a = 10;
定义常量哦

变量，会变化的量，可以重新定义

把const去掉即可
会变化
easy
定义：
变量类型 变量名[=变量初始值]；
变量类型 变量名；

变量三要素：
类型名
变量名
变量值

变量可以是不赋值
可以赋值
可以赋予表达式

变量的存储图很重要。

void f2(void)
{//变量int r = 3;//变量的值，可以是表达式float s = PI * r * r;//浮点数--也是有效变量}int main(void)
{f2();system("pause");return 0;
}

r可以开辟存储空间
名字就叫r
它的地址时ptr指向的

变量值，放在了r中，大小多大，就是看数据类型了，类型越大，空间越大

变量的声明
值是不给的

我们可以只声明，而不用

添加了关键字extern，变量定义，会开辟内存空间
变量申明不会开辟内存空间

只声明，是不会有内存空间的。

当编译器编译程序时，
在变量使用之前，如果没有定义，编译器会自动找一个变量声明，提升成为定义
在使用变量之前，你必须定义它的值
全局是0，局部是看操作系统，Windows不让你过，Linux给随机数。

如果使用前，有extern关键字，无法提升。
在使用之前，你编译器不要给我赋值

重新赋值；
变量你定义好了，重新修改变量值
好说

使用变量前，一定要定义哦
申明这种是会自动提升定义的
除非你家extern

建议：
定义变量，或申明变量时，尽量不要重名

标识符命名规则

一个变量啥的就是一种标识符
常量使用大写
变量小写
大小写严格区分哦

只能使用字母、数字、下划线_来命令，其他的字符不行哦，且数字不能开头哦

int c;c = PI;//替换

常量可以赋值给变量

使用变量后，输出即可

OK，标识符到此为止

int类型，整型

short 类型 short a = 10;
long类型 long a = 10;
long long类型
都是整型
只是长度不同，范围不同
变量的空间大小有区别

如何查看这些类型的存储空间大小

它竟然不是函数，只是关键字而已
应该说看看你这个变量占用多少字节

void f4(void)
{int a = 10;short b = 10;long c = 10;long long d = 10;printf("int类型大小：%d\\n", sizeof(int));printf("short类型大小：%d\\n", sizeof(short));printf("long类型大小：%d\\n", sizeof(long));printf("long long类型大小：%d\\n", sizeof(long long));
}int main(void)
{f4();system("pause");return 0;
}

short竟然比int还小2字节
int是4字节
long也是4字节
longlong俩int呗

这些需要记住哦

void f4(void)
{int a = 10;short b = 10;long c = 10;long long d = 10;printf("int类型大小：%d\\n", sizeof(int));printf("int类型大小：%d\\n", sizeof(a));printf("short类型大小：%d\\n", sizeof(short));printf("short类型大小：%d\\n", sizeof(b));printf("long类型大小：%d\\n", sizeof(long));printf("long类型大小：%d\\n", sizeof(c));printf("long long类型大小：%d\\n", sizeof(long long));printf("long long类型大小：%d\\n", sizeof(d));
}int main(void)
{f4();system("pause");return 0;
}

所以sizeof既可以传类型本身
也可以传变量

都能玩

这些c++都是通用的

咱们看看常量宏定义，它的空间大小是多少

#define N 1024  //常量定义
void f5(void)
{int a = 10;//变量定义printf("a大小：%d\\n", sizeof(a));printf("N类型大小：%d\\n", sizeof(N));
}int main(void)
{f5();system("pause");return 0;
}

常量是不申请内存的，直接用，它长度是4字节

标识符不可以用关键字哦

总结sizeof关键字

无符号整型unsigned

signed不写
unsigned要写是无符号

取值不看符号，二进制的开头1就不算了，那就扩大了一倍的表示范围
值的范围是大一丢丢

void f6(void)
{unsigned int a;a = -10;printf("a：%d\\n",a);printf("a大小：%d\\n", sizeof(a));
}

虽然可以这写，但是吧，就强行转了

大小是都不变的哦
跟你有符号无符号没关系

long为啥和int一样
早期long才是int
int那会才是2字节
后来int改为short了

int在Windows下面的32位系统和64位系统下，int都是4字节
而在Linux下面的32系统int是4字节，而Linux的64位系统int是8字节
懂？

打印的时候，格式匹配符号是，都从int衍生出来的
int用%d打印
short用%hd打印
long用%ld打印
long long用%lld打印

unsigned int用%u打印
unsigned short用%hu打印
unsigned long用%lu打印
unsigned long long用%llu打印


还有定义long类型数据的话
可以写为5l
5ll
这俩不常用的

void f6(void)
{unsigned int a=10;unsigned short b=11;unsigned long c = 12;unsigned long long d = 13;printf("a：%u\\n",a);printf("b：%hu\\n",b);printf("c：%lu\\n",c);printf("d：%llu\\n",d);
}int main(void)
{f6();system("pause");return 0;
}

size_t是一种啥类型
typedef unsigned int size_t;
定义一个无符号整型
没有符号的整型

// Definitions of common types
#ifdef _WIN64typedef unsigned __int64 size_t;typedef __int64          ptrdiff_t;typedef __int64          intptr_t;
#elsetypedef unsigned int     size_t;typedef int              ptrdiff_t;typedef int              intptr_t;

如果是64位Windows系统，那走上面一路
32位Windows系统，走下面无符号int类型

void f6(void)
{unsigned int a=10;unsigned short b=11;unsigned long c = 12;unsigned long long d = 13;printf("a：%u\\n",a);printf("b：%hu\\n",b);printf("c：%lu\\n",c);printf("d：%llu\\n",d);size_t k = 10;//自定义的类型printf("d：%u\\n", k);//无符号int哦}

懂了吧用size_t的话，就要用%u匹配

字符类型，字符串类型

char
字符串类型：存储一个字符
''单引号引起来的叫字符
‘a’
‘B’
‘1’

格式匹配符%c
char的简称c
类型名变量名=变量值;

void f7(void)
{char ch = 'a';//ASCII码printf("字符ch：%c\\n", ch);ch = 'm';printf("字符ch：%c\\n", ch);ch = 97;//ASCII字符编码，它会打印字符printf("字符ch：%c\\n", ch);
}

说明字符，实际上是一个ASCII码而已

void f7(void)
{char ch = 'a';//ASCII码printf("字符ch：%c\\n", ch);printf("字符ch：%d\\n", ch);ch = 'm';printf("字符ch：%c\\n", ch);printf("字符ch：%d\\n", ch);ch = 97;//ASCII字符编码，它会打印字符printf("字符ch：%c\\n", ch);printf("字符ch：%d\\n", ch);
}

void f7(void)
{char ch = 'A';//ASCII码printf("字符ch：%c\\n", ch);printf("字符ch：%d\\n", ch);ch = 'm';printf("字符ch：%c\\n", ch);printf("字符ch：%d\\n", ch);ch = 97;//ASCII字符编码，它会打印字符printf("字符ch：%c\\n", ch);printf("字符ch：%d\\n", ch);
}

A=65
Z=65+25=90
a=97
z=97+25=122

void f7(void)
{char ch = 'A';//ASCII码printf("字符ch：%c\\n", ch);printf("字符ch：%d\\n", ch);ch = 'Z';//ASCII码printf("字符ch：%c\\n", ch);printf("字符ch：%d\\n", ch);ch = 'a';printf("字符ch：%c\\n", ch);printf("字符ch：%d\\n", ch);ch = 'z';//ASCII字符编码，它会打印字符printf("字符ch：%c\\n", ch);printf("字符ch：%d\\n", ch);
}

我们可以把大写字母转化为小写
那就是大写的ASCII加32即可

void f7(void)
{char ch = 'A';//ASCII码printf("字符ch：%c\\n", ch);printf("字符ch：%d\\n", ch);ch = 'Z';//ASCII码printf("字符ch：%c\\n", ch);printf("字符ch：%d\\n", ch);ch = 'A'+32;printf("字符ch：%c\\n", ch);printf("字符ch：%d\\n", ch);ch = 'Z' + 32;//ASCII字符编码，它会打印字符printf("字符ch：%c\\n", ch);printf("字符ch：%d\\n", ch);
}

咋样，好说吧

字符’0’对应的ASCII码是48

如果你要打印\\n出来
那你需要转义字符\\

\\0是数字0哦
而不是字符0

void f8(void)
{char c = '\\n';printf("\\\\n:%c", c);
}

实数类型，浮点型

float和double不常用的

单精度浮点型float，精度低4字节
双精度浮点型，精度高8字节

void f9(void)
{float a = 3.14;double b = 3.14159;printf("a=%f\\n", a);printf("b=%lf\\n", b);printf("a大小=%d\\n", sizeof(a));printf("b大小=%d\\n", sizeof(b));
}

long float=double
默认float是保留6位小数点
需要限定小数保留几位就%.kf

void f9(void)
{float a = 3.14159;double b = 3.14159;printf("a=%.2f\\n", a);printf("b=%.3lf\\n", b);printf("a大小=%d\\n", sizeof(a));printf("b大小=%d\\n", sizeof(b));
}

它会四舍五入的

void f9(void)
{float a = 3.14159;double b = 3.14159;printf("a=%.2f\\n", a);printf("b=%.3lf\\n", b);printf("a大小=%d\\n", sizeof(a));printf("b大小=%d\\n", sizeof(b));a = 3.2e3f;//科学计数法，3.2×10的3次方即3200printf("a=%f\\n", a);a = 3.2e-3f;//科学计数法，3.2×10的-3次方即0.0032printf("a=%f\\n", a);
}

总结

提示：重要经验：

1）
2）学好c++，即使经济寒冬，手握10个大厂offer绝对不是问题！
3）笔试求AC，可以不考虑空间复杂度，但是面试既要考虑时间复杂度最优，也要考虑空间复杂度最优。