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

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++：常量，不会变化的数据

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

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

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

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

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

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

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

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

#include
#include
#include
#include
#include

//很多库后续调用各种函数都需要用的

//定义常量
#define PI 3.14

void f1(void)
{
	//圆的面积s=pi*r*r
	//圆的周长c=2*pi*r
	int 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*r
	int r = 3;//变量半径
	float s = 3.14; * r * r;//浮点数

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

#include
#include
#include
#include
#include

//很多库后续调用各种函数都需要用的

//定义常量
#define PI 3.14

void f1(void)
{
	//圆的面积s=pi*r*r
	//圆的周长c=2*pi*r
	int 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 _WIN64
    typedef unsigned __int64 size_t;
    typedef __int64          ptrdiff_t;
    typedef __int64          intptr_t;
#else
    typedef 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次方即3200
	printf("a=%f\n", a);
	a = 3.2e-3f;//科学计数法，3.2×10的-3次方即0.0032
	printf("a=%f\n", a);
}

---

总结

提示：重要经验：

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