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.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<stdio.h>
#include<string.h>
#include<stdlib.h>
#include<math.h>
#include<time.h>

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

//定义常量
#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);
}