C语言概述
- 什么是C语言
C语言是人和机器交流。只是，人可以不听另外一个人，但是，计算机是无条件服从。
语言有独特的语法规则和定义，双方必须遵循这些规则和定义才能实现真正的交流。
- 为什么要学习C语言
C语言特点
- 优点
- 代码量小
- 执行速度快
- 功能强大
- 编程自由
- 缺点
- 写代码实现周期长
- 可移植性较差
- 过于自由，经验不足易出错
- 对平台库依赖较多
1.2.2 学习C语言理由
1.2.3 C语言应用领域
C语言的应用极其广泛，从网站后台，到底层操作系统，从多媒体应用到大型网络游戏，均可使用C语言来开发：
- C语言可以写网站后台程序
- C语言可以专门针对某个主题写出功能强大的程序库
- C语言可以写出大型游戏的引擎
- C语言可以写出另一个语言来
- C语言可以写操作系统和驱动程序，并且只能用C语言编写
- C 任何设备只要配置了微处理器，就都支持C语言。从微波炉到手机，都是由C语言技术来推动的
C语言的简洁
C语言仅有32个关键字，9种控制语句，34种运算符，却能完成无数的功能：
- 学习C语言的常见困惑
第一个C语言程序：HelloWorld 编写C语言代码：hello.c
#include <stdio.h>
int main()
{
//这是第一个C语言代码
printf("hello world\n");
return 0;
}
C语言的源代码文件是一个普通的文本文件，但扩展名必须是.c。
- 通过gcc编译C代码
- gcc编译器介绍
编辑器(如vi、记事本)是指我用它来写程序的（编辑代码），而我们写的代码语句，电脑是不懂的，我们需要把它转成电脑能懂的语句，编译器就是这样的转化工具。就是说，我们用编辑器编写程序，由编译器编译后才可以运行！
编译器是将易于编写、阅读和维护的高级计算机语言翻译为计算机能解读、运行的低级机器语言的程序。
gcc（GNU Compiler Collection，GNU 编译器套件），是由 GNU 开发的编程语言编译器。gcc原本作为GNU操作系统的官方编译器，现已被大多数类Unix操作系统（如Linux、BSD、Mac OS X等）采纳为标准的编译器，gcc同样适用于微软的Windows。
gcc最初用于编译C语言，随着项目的发展gcc已经成为了能够编译C、C++、Java、Ada、fortran、Object C、Object C++、Go语言的编译器大家族。
编译命令格式：
gcc [-option1] …
g++ [-option1] …
- 命令、选项和源文件之间使用空格分隔
- 一行命令中可以有零个、一个或多个选项
- 文件名可以包含文件的绝对路径，也可以使用相对路径
- 如果命令中不包含输出可执行文件的文件名，可执行文件的文件名会自动生成一个默认名，Linux平台为a.out，Windows平台为a.exe
gcc、g++编译常用选项说明：
选项 含义
-o file 指定生成的输出文件名为file
-E 只进行预处理
-S(大写) 只进行预处理和编译
-c(小写) 只进行预处理、编译和汇编
- Windows平台下gcc环境配置
#include <stdio.h>
#include <stdlib.h>
int main()
{
printf("hello world\n");
system("pause");
return 0;
}
1.3.3 代码分析
- include头文件包含
- #include的意思是头文件包含，#include <stdio.h>代表包含stdio.h这个头文件
使用C语言库函数需要提前包含库函数对应的头文件，如这里使用了printf()函数，需要包含stdio.h头文件
#include< > 与 #include ""的区别：
- < > 表示系统直接按系统指定的目录检索
- " " 表示系统先在 “” 指定的路径(没写路径代表当前路径)查找头文件，如果找不到，再按系统指定的目录检索
stdio.h是在操作系统的系统目录下：
- main函数
- 一个完整的C语言程序，是由一个、且只能有一个main()函数(又称主函数，必须有)和若干个其他函数结合而成（可选）。
- main函数是C语言程序的入口，程序是从main函数开始执行。
- {} 括号，程序体和代码块
- {}叫代码块，一个代码块内部可以有一条或者多条语句
- C语言每句可执行代码都是";"分号结尾
- 所有的#开头的行，都代表预编译指令，预编译指令行结尾是没有分号的
- 所有的可执行语句必须是在代码块里面
- 注释
- //叫行注释，注释的内容编译器是忽略的，注释主要的作用是在代码中加一些说明和解释，这样有利于代码的阅读
- /**/叫块注释
- 块注释是C语言标准的注释方法
- 行注释是从C++语言借鉴过来的
-
printf函数
printf是C语言库函数，功能是向标准输出设备输出一个字符串
printf(“hello world\n”);//\n的意思是回车换行 -
return语句
- return代表函数执行完毕，返回return代表函数的终止
- 如果main定义的时候前面是int，那么return后面就需要写一个整数；如果main定义的时候前面是void，那么return后面什么也不需要写
- 在main函数中return 0代表程序执行成功，return -1代表程序执行失败
- int main()和void main()在C语言中是一样的，但C++只接受int main这种定义方式
7)system函数的使用
#include <stdlib.h>
system(“pause”); // 一直显示控制台程序
C语言编译过程
- C程序编译步骤
C代码编译成可执行程序经过4步：
1）预处理：宏定义展开、头文件展开、条件编译等，同时将代码中的注释删除，这里并不会检查语法
2）编译：检查语法，将预处理后文件编译生成汇编文件
3）汇编：将汇编文件生成目标文件(二进制文件)
4）链接：C语言写的程序是需要依赖各种库的，所以编译之后还需要把库链接到最终的可执行程序中去
gcc编译过程
- 分步编译
预处理：gcc -E hello.c -o hello.i
编 译：gcc -S hello.i -o hello.s
汇 编：gcc -c hello.s -o hello.o
链 接：gcc hello.o -o hello
选项 含义
-E 只进行预处理
-S(大写) 只进行预处理和编译
-c(小写) 只进行预处理、编译和汇编
-o file 指定生成的输出文件名为 file
文件后缀 含义
.c C 语言文件
.i 预处理后的 C 语言文件
.s 编译后的汇编文件
.o 编译后的目标文件
- 一步编译
gcc hello.c -o demo（还是经过：预处理、编译、汇编、链接的过程）：
CPU内部结构与寄存器(了解)
64位和32位系统区别
- 寄存器是CPU内部最基本的存储单元
- CPU对外是通过总线(地址、控制、数据)来和外部设备交互的，总线的宽度是8位，同时CPU的寄存器也是8位，那么这个CPU就叫8位CPU
- 如果总线是32位，寄存器也是32位的，那么这个CPU就是32位CPU
- 有一种CPU内部的寄存器是32位的，但总线是16位，准32为CPU
- 所有的64位CPU兼容32位的指令，32位要兼容16位的指令，所以在64位的CPU上是可以识别32位的指令
- 在64位的CPU构架上运行了64位的软件操作系统，那么这个系统是64位
- 在64位的CPU构架上，运行了32位的软件操作系统，那么这个系统就是32位
- 64位的软件不能运行在32位的CPU之上
寄存器名字(了解)
1.6.3 寄存器、缓存、内存三者关系
按与CPU远近来分，离得最近的是寄存器，然后缓存(CPU缓存)，最后内存。
CPU计算时，先预先把要用的数据从硬盘读到内存，然后再把即将要用的数据读到寄存器。于是 CPU<—>寄存器<—>内存，这就是它们之间的信息交换。
那为什么有缓存呢？因为如果经常操作内存中的同一址地的数据，就会影响速度。于是就在寄存器与内存之间设置一个缓存。
因为从缓存提取的速度远高于内存。当然缓存的价格肯定远远高于内存，不然的话，机器里就没有内存的存在。
由此可以看出，从远近来看：CPU〈—〉寄存器〈—> 缓存 <—> 内存。
注释
数据类型本身不会被执行, 是给别人看的, 对程序的解释
单行注释 //
多行注释 /* */
常量与变量
- 关键字
- 数据类型
数据类型的作用：编译器预算对象（变量）分配的内存空间大小。
变量
- 在程序运行过程中，其值可以改变
- 变量在使用前必须先定义，定义变量前必须有相应的数据类型
标识符命名规则：
- 标识符不能是关键字
- 标识符只能由字母、数字、下划线组成
- 第一个字符必须为字母或下划线
- 标识符中字母区分大小写
变量特点：
- 变量在编译时为其分配相应的内存空间
- 可以通过其名字和地址访问相应内存
声明和定义区别
- 声明变量不需要建立存储空间，如：extern int a;
- 定义变量需要建立存储空间，如：int b;
#include <stdio.h>
int main()
{
//extern 关键字只做声明，不能做任何定义，后面还会学习，这里先了解
//声明一个变量a，a在这里没有建立存储空间
extern int a;
a = 10; //err, 没有空间，就不可以赋值
int b = 10; //定义一个变量b，b的类型为int，b赋值为10
return 0;
}
从广义的角度来讲声明中包含着定义，即定义是声明的一个特例，所以并非所有的声明都是定义：
- int b 它既是声明，同时又是定义
- 对于 extern b来讲它只是声明不是定义
一般的情况下，把建立存储空间的声明称之为“定义”，而把不需要建立存储空间的声明称之为“声明”。
常量
作用: ⽤于记录程序中不可更改的数据
C 定义常量两种⽅式
1. #define 宏常量： #define 常量名 常量值 通常在⽂件上⽅定义，表⽰⼀个常量
2. const修饰的变量 const 数据类型 常量名 = 常量值
通常在变量定义前加关键字const，修饰该变量为常量，不可修改
#include <stdio.h>
#define MAX 10 //声明了一个常量，名字叫MAX，值是10，常量的值一旦初始化不可改
int main()
{
int a; //定义了一个变量，其类型为int，名字叫a
const int b = 10; //定义一个const常量，名为叫b，值为10
//b = 11; //err,常量的值不能改变
//MAX = 100; //err,常量的值不能改变
a = MAX;//将abc的值设置为MAX的值
a = 123;
printf("%d\n", a); //打印变量a的值
return 0;
}
- 整型：int
整型变量的定义和输出
#include <stdio.h>
int main()
{
int a = 123; //定义变量a，以10进制方式赋值为123
int b = 0567; //定义变量b，以8进制方式赋值为0567
int c = 0xabc; //定义变量c，以16进制方式赋值为0xabc
printf("a = %d\n", a);
printf("8进制：b = %o\n", b);
printf("10进制：b = %d\n", b);
printf("16进制：c = %x\n", c);
printf("16进制：c = %X\n", c);
printf("10进制：c = %d\n", c);
unsigned int d = 0xffffffff; //定义无符号int变量d，以16进制方式赋值
printf("有符号方式打印：d = %d\n", d);
printf("无符号方式打印：d = %u\n", d);
return 0;
}
Clion乱码
选gbk
- 整型变量的输入
#include <stdio.h>
int main()
{
int a;
printf("请输入a的值：");
//不要加“\n”
scanf("%d", &a);
printf("a = %d\n", a); //打印a的值
return 0;
}
- short、int、long、long long
注意： - 需要注意的是，整型数据在内存中占的字节数与所选择的操作系统有关。虽然 C 语言标准中没有明确规定整型数据的长度，但 long 类型整数的长度不能短于 int 类型， short 类型整数的长度不能长于 int 类型。
- 当一个小的数据类型赋值给一个大的数据类型，不会出错，因为编译器会自动转化。但当一个大的类型赋值给一个小的数据类型，那么就可能丢失高位。
#include <stdio.h>
int main()
{
short a = 10;
int b = 10;
long c = 10l; //或者10L
long long d = 10ll; //或者10LL
printf("sizeof(a) = %u\n", sizeof(a));
printf("sizeof(b) = %u\n", sizeof(b));
printf("sizeof(c) = %u\n", sizeof(c));
printf("sizeof(c) = %u\n", sizeof(d));
printf("short a = %hd\n", a);
printf("int b = %d\n", b);
printf("long c = %ld\n", c);
printf("long long d = %lld\n", d);
unsigned short a2 = 20u;
unsigned int b2 = 20u;
unsigned long c2= 20ul;
unsigned long long d2 = 20ull;
printf("unsigned short a = %hu\n", a2);
printf("unsigned int b = %u\n", b2);
printf("unsigned long c = %lu\n", c2);
printf("unsigned long long d = %llu\n", d2);
return 0;
}
- 有符号数和无符号数区别
- 有符号数
有符号数是最高位为符号位，0代表正数，1代表负数。
#include <stdio.h>
int main()
{
signed int a = -1089474374; //定义有符号整型变量a
printf("%X\n", a); //结果为 BF0FF0BA
//B F 0 F F 0 B A
//1011 1111 0000 1111 1111 0000 1011 1010
return 0;
}
- 无符号数
无符号数最高位不是符号位，而就是数的一部分，无符号数不可能是负数
#include <stdio.h>
int main()
{
unsigned int a = 3236958022; //定义无符号整型变量a
printf("%X\n", a); //结果为 C0F00F46
return 0;
}
当我们写程序要处理一个不可能出现负值的时候，一般用无符号数，这样可以增大数的表达最大值
3) 有符号和无符号整型取值范围
sizeof关键字
- sizeof不是函数，所以不需要包含任何头文件，它的功能是计算一个数据类型的大小，单位为字节
- sizeof的返回值为size_t
- size_t类型在32位操作系统下是unsigned int，是一个无符号的整数
#include <stdio.h>
int main()
{
int a;
int b = sizeof(a);//sizeof得到指定值占用内存的大小，单位：字节
printf("b = %d\n", b);
size_t c = sizeof(a);
printf("c = %u\n", c);//用无符号数的方式输出c的值
return 0;
}
字符型：char
字符变量的定义和输出
字符型变量用于存储一个单一字符，在 C 语言中用 char 表示，其中每个字符变量都会占用 1 个字节。在给字符型变量赋值时，需要用一对英文半角格式的单引号(’ ')把字符括起来。字符变量实际上并不是把该字符本身放到变量的内存单元中去，而是将该字符对应的 ASCII 编码放到变量的存储单元中。char的本质就是一个1字节大小的整型。
#include <stdio.h>
int main()
{
char ch = 'a';
printf("sizeof(ch) = %u\n", sizeof(ch));
printf("ch[%%c] = %c\n", ch); //打印字符
printf("ch[%%d] = %d\n", ch); //打印‘a’ ASCII的值
char A = 'A';
char a = 'a';
printf("a = %d\n", a); //97
printf("A = %d\n", A); //65
printf("A = %c\n", 'a' - 32); //小写a转大写A
printf("a = %c\n", 'A' + 32); //大写A转小写a
ch = ' ';
printf("空字符：%d\n", ch); //空字符ASCII的值为32
printf("A = %c\n", 'a' - ' '); //小写a转大写A
printf("a = %c\n", 'A' + ' '); //大写A转小写a
return 0;
}
字符变量的输入
#include <stdio.h>
int main()
{
char ch;
printf("请输入ch的值：");
//不要加“\n”
scanf("%c", &ch);
printf("ch = %c\n", ch); //打印ch的字符
return 0;
}
ASCII对照表
ASCII 码大致由以下两部分组成：
ASCII 非打印控制字符： ASCII 表上的数字 0-31 分配给了控制字符，用于控制像打印机等一些外围设备。
ASCII 打印字符：数字 32-126 分配给了能在键盘上找到的字符，当查看或打印文档时就会出现。数字 127 代表 Del 命令。
转义字符
注意：红色字体标注的为不可打印字符。
#include <stdio.h>
int main()
{
printf("abc");
printf("\refg\n"); //\r切换到句首， \n为换行键
printf("abc");
printf("\befg\n");//\b为退格键， \n为换行键
printf("%d\n", '\123');// '\123'为8进制转义字符，0123对应10进制数为83
printf("%d\n", '\x23');// '\x23'为16进制转义字符，0x23对应10进制数为35
return 0;
}
实型(浮点型)：float、double
实型变量也可以称为浮点型变量，浮点型变量是用来存储小数数值的。在C语言中， 浮点型变量分为两种： 单精度浮点数(float)、 双精度浮点数(double)， 但是double型变量所表示的浮点数比 float 型变量更精确。
由于浮点型变量是由有限的存储单元组成的，因此只能提供有限的有效数字。在有效位以外的数字将被舍去，这样可能会产生一些误差。
不以f结尾的常量是double类型，以f结尾的常量(如3.14f)是float类型。
#include <stdio.h>
int main()
{
//传统方式赋值
float a = 3.14f; //或3.14F
double b = 3.14;
printf("a = %f\n", a);
printf("b = %lf\n", b);
//科学法赋值
a = 3.2e3f; //3.2*1000 = 3200，e可以写E
printf("a1 = %f\n", a);
a = 100e-3f; //100*0.001 = 0.1
printf("a2 = %f\n", a);
a = 3.1415926f;
printf("a3 = %f\n", a); //结果为3.141593
return 0;
}
数值溢出
当超过一个数据类型能够存放最大的范围时，数值会溢出。
有符号位最高位溢出的区别：符号位溢出会导致数的正负发生改变，但最高位的溢出会导致最高位丢失。
#include <stdio.h>
int main()
{
char ch;
//符号位溢出会导致数的正负发生改变
ch = 0x7f + 2; //127+2
printf("%d\n", ch);
// 0111 1111
//+2后 1000 0001，这是负数补码，其原码为 1111 1111，结果为-127
//最高位的溢出会导致最高位丢失
unsigned char ch2;
ch2 = 0xff+1; //255+1
printf("%u\n", ch2);
// 1111 1111
//+1后 10000 0000， char只有8位最高位的溢出，结果为0000 0000，十进制为0
ch2 = 0xff + 2; //255+1
printf("%u\n", ch2);
// 1111 1111
//+1后 10000 0001， char只有8位最高位的溢出，结果为0000 0001，十进制为1
return 0;
}
类型限定符
字符串格式化输出和输入
字符串常量
-
字符串是内存中一段连续的char空间，以’\0’(数字0)结尾。
-
字符串常量是由双引号括起来的字符序列，如“china”、“C program”，“$12.5”等都是合法的字符串常量。
字符串常量与字符常量的不同：
每个字符串的结尾，编译器会自动的添加一个结束标志位’\0’，即 “a” 包含两个字符’a’和’\0’。 -
printf函数和putchar函数
printf是输出一个字符串，putchar输出一个char。
printf格式字符：
printf附加格式：
#include <stdio.h>
int main()
{
int a = 100;
printf("a = %d\n", a);//格式化输出一个字符串
printf("%p\n", &a);//输出变量a在内存中的地址编号
printf("%%d\n");
char c = 'a';
putchar(c);//putchar只有一个参数，就是要输出的char
long a2 = 100;
printf("%ld, %lx, %lo\n", a2, a2, a2);
long long a3 = 1000;
printf("%lld, %llx, %llo\n", a3, a3, a3);
int abc = 10;
printf("abc = '%6d'\n", abc);
printf("abc = '%-6d'\n", abc);
printf("abc = '%06d'\n", abc);
printf("abc = '%-06d'\n", abc);
double d = 12.3;
printf("d = \' %-10.3lf \'\n", d);
return 0;
}
scanf函数与getchar函数
- getchar是从标准输入设备读取一个char。
- scanf通过%转义的方式可以得到用户通过标准输入设备输入的数据。
#include <stdio.h>
int main()
{
char ch1;
char ch2;
char ch3;
int a;
int b;
printf("请输入ch1的字符：");
ch1 = getchar();
printf("ch1 = %c\n", ch1);
getchar(); //测试此处getchar()的作用
printf("请输入ch2的字符：");
ch2 = getchar();
printf("\'ch2 = %ctest\'\n", ch2);
getchar(); //测试此处getchar()的作用
printf("请输入ch3的字符：");
scanf("%c", &ch3);//这里第二个参数一定是变量的地址，而不是变量名
printf("ch3 = %c\n", ch3);
printf("请输入a的值：");
scanf("%d", &a);
printf("a = %d\n", a);
printf("请输入b的值：");
scanf("%d", &b);
printf("b = %d\n", b);
return 0;
}
C++
Clion的基本使用
插件安装
single file execution
打开cmakelist.txt
cmake_minimum_required(VERSION 3.19) 这是指定cmake执行的最小版本
project(c_workspace1) 项目名
set(CMAKE_CXX_STANDARD 11) # 语言版本
add_executable(c_workspace1 demo1.cpp) 将我们的cpp文件注册到cmakelist中
第一个参数是项目名, 第二个参数cpp文件名
自己编写一个helloword文件
#include <iostream>
using namespace std;
int main(){
cout<< "hello" << endl;
}
增加第二个文件的操作
基本shell命令
tab键可以进行代码补全, / 是根目录, ~是用户目录
- 切换文件夹
cd 目录名
- 列出文件夹中所有文件列表
ls
- 当前所在目录
pwd
- 清屏
clear
- 后退一级目录
cd ..
- 建立day01文件夹
mkdir day01
- 建立demo1.cpp文件
touch demo1.cpp
- 编辑demo1.cpp
vim demo1.cpp
i 是进入编辑状态; 编辑完毕后按esc ; 输入 :wq保存退出
- 查看demo1.cpp
cat demo1.cpp
- 编译c++文件
g++ -o demo1 demo1.cpp
g++ -o 源文件名 编译源文件
- 执行 demo1 这个可执行文件
./demo1
- 删除hello.txt
rm -f hello.txt
- 重名命名文件
mv demo1.cpp demo2.cpp
- 移动文件
mv demo2.cpp /Users/ericli/CLionProjects/houjiheng/demo2.cpp
- 复制
cp demo2.cpp /Users/ericli/CLionProjects/houjiheng/demo2.cpp
C编译
使用gcc -o 编译文件的名字 源文件
延展Java的编译
C++注释
本身不会被执行, 是给别人看的, 对程序的解释
单行注释 //
多行注释 /* */
变量
给⼀段指定的内存空间起名，⽅便操作这段内存
格式: 数据类型 变量名 = 变量值;
#include <iostream>
using namespace std;
int main(){
// c++中创建变量是必须要给变量一个初始值,否则会报错
// 第一种变量声明方式. 声明+初始化
int a = 888;
a = 333;
cout<< "a = " << a << endl;
// 第二种变量声明方式 先声明 在初始化
int b;
b = 999;
cout<< "b = " << b << endl;
}
常量
作用: ⽤于记录程序中不可更改的数据
C++定义常量两种⽅式
1. #define 宏常量： #define 常量名 常量值 通常在⽂件上⽅定义，表⽰⼀个常量
2. const修饰的变量 const 数据类型 常量名 = 常量值
通常在变量定义前加关键字const，修饰该变量为常量，不可修改
举个例子
#include <iostream>
#define day 7
#define PI 3.14
using namespace std;
// 常量
int main(){
// 宏常量
cout<< "a week have "<< day << " days"<< endl;
cout<< "PI = "<< PI << endl;
// const 修饰变量
const int month = 12;
// month = 13; 常量是不能修改的 会报错
cout<< "month = "<< month << endl;
}
关键字(保留字)
注意: 在定义变量或者常量时候，不要⽤关键字
作⽤：关键字是C++中预先保留的单词（标识符）
标识符
C++规定给标识符（变量、常量）命名时，有⼀套⾃⼰的规则
- 标识符不能是关键字
- 标识符只能由字⺟、数字、下划线(美元符也行)组成
- 第⼀个字符必须为字⺟或下划线
- 标识符中字⺟区分⼤⼩写
#include <iostream>
using namespace std;
int main(){
# 两个变量
int num = 100;
int NUM = 200;
cout<< num << endl;
cout<< NUM << endl;
}
数据类型
C++规定在创建⼀个变量或者常量时，必须要指定出相应的数据类型，否则⽆法给变量分配内存
1 字节(Byte) = 8 位(bit)
- 整型
整型变量表⽰的是整数类型的数据
sizeof关键字
利⽤sizeof关键字可以统计数据类型所占内存⼤⼩
语法： sizeof( 数据类型/ 变量)
#include <iostream>
using namespace std;
// size of
int main(){
int a =100;
cout<< "short = "<< sizeof(short)<<endl;
cout<< "int = "<< sizeof(int)<<endl;
cout<< "long = "<< sizeof(long)<<endl;
cout<< "long long = "<< sizeof(long long )<<endl;
cout<< "a = "<< sizeof(a)<<endl;
// 结论
// short < int <= long <= long long
}
浮点型(小数/实型)
浮点型有两种
- 单精度float
- 双精度double
两者的区别在于表示有效数字范围不同
#include <iostream>
using namespace std;
int main(){
cout.precision(10);// 设置consle输出有效数字的范围
float f1 = 3.141592653f;//整数部分也算有效位的范围
double d1 = 3.141592653;
cout<< f1 << endl;
cout<< d1 << endl;
cout<<"float sizeof = " <<sizeof(f1)<< endl; // 4
cout<<"double sizeof = " <<sizeof(d1)<< endl; // 8
// 科学计数法
float f2 = 3e2; // 3*10^2
cout<<"f2 = " <<f2<< endl; //
float f3 = -4e3; // -4*10^3
cout<<"f3 = " <<f3<< endl; //
float f4 = 4e-2; // 4* 10 -2 次方 计算机浮点数计算会损失精度
cout<<"f4 = " <<f4<< endl; //
}
字符型 (char型)
作用: 字符型变量⽤于显⽰单个字符
- C和C++中字符型变量只占⽤1个字节
- 字符型变量并不是把字符本⾝放到内存中存储，⽽是将对应的ASCII编码放⼊到存储单元
#include <iostream>
using namespace std;
// 字符型
int main(){
char ch = 'a'; // 单引号
cout<<"ch = " <<ch<< endl; //
cout<<"size of char " <<sizeof(ch)<< endl; // 占一个字节
// ch = 'abcde'; // 错误 单引号内只能是一个字符
// ch = "abcde"; // 错误 不能用双引号
// 查看字符对应的 ASCII码
cout<<"a ASCII码 = " <<(int)ch<< endl; // 97
char ch2 = 'A'; // 单引号
cout<<"A ASCII码 = " <<(int)ch2<< endl; // 97
// 可以直接用ascii码给字符型变量赋值
ch = 97;
char ch3 = 98;
cout<<"ch = " <<ch<< endl; // 97
cout<<"ch3 = " <<ch3<< endl; // 97
}
ASCII 码⼤致由以下两部分组成：
- ASCII ⾮打印控制字符： ASCII 表上的数字 0-31 分配给了控制字符，⽤于控制像打印机等⼀些外围 设备。
- ASCII 打印字符：数字 32-126 分配给了能在键盘上找到的字符，当查看或打印⽂档时就会出现。
转义字符
作⽤：⽤于表⽰⼀些不能显⽰出来的ASCII字符
现阶段我们常⽤的转义字符有： \n \ \t
#include <iostream>
using namespace std;
// 转义字符
int main(){
// \本身代表转义的意思, 他已经不是本身\的意思了
cout<< "\\" << endl; // 只输出一个斜杠
// 换行
cout<< "hello\nhaha" << endl; // 只输出一个斜杠
// 等价于tab键
cout<< "hello\thaha" << endl; // 只输出一个斜杠
}
字符串型
作⽤：⽤于表⽰⼀串字符
两种风格
-
- C风格字符串 : char 变量名[] = “字符串值”
#include <iostream>
using namespace std;
// 字符串
int main(){
char str1[] = "hello world";
cout<< str1 << endl;
}
-
- C++风格字符串 : string 变量名 = “字符串值”
#include <iostream>
#include <string>
using namespace std;
// 字符串
int main(){
char str1[] = "hello world";
cout<< str1 << endl;
string str = "hello world";
cout<< str << endl;
}
c++风格字符串需要引入头文件#include
布尔数据类型 bool
布尔数据类型代表真或假的值
布尔数据类型代表真或假的值
bool类型只有两个值：
- true — 真（本质是1）
-false — 假（本质是0）
bool类型占1个字节⼤⼩
#include <iostream>
using namespace std;
int main(){
bool flag = true;
cout<< flag << endl;// 1
flag = false;
cout<< flag << endl;// 0
cout<< "bool size" <<sizeof(flag)<< endl;// 1
}
console输入
cin >> 变量
#include <iostream>
using namespace std;
int main(){
// 整型输入
int a;
cout << "please input a number "<<endl;
cin>>a;
cout << "a = "<< a << endl;
// 浮点型输入
double d;
cout << "please input double number "<<endl;
cin>>d;
cout << "d = "<< d << endl;
// 字符型输入
char ch;
cout << "please input a char "<<endl;
cin>>ch;
cout << "ch = "<< ch << endl;
// 字符串型输入
string str;
cout << "please input a string "<<endl;
cin>>str;
cout << "str = "<< str << endl;
// 布尔型输入
bool flag;
cout << "please input a bool value "<<endl;
cin>>flag;
cout << "flag = "<< flag << endl;
}
399
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
