C++笔记简要概述

引言

大家好，本人是c语言初学者，简要整理了c语言的章节和部分难点，并不详尽和严谨，有误处还望指正，也希望海涵，我会不断改进，谢谢大家。

前提基础提要

文件

           源文件格式：.c结尾

           头文件格式：.h结尾

头文件和源文件之间存在某种关联性。头文件通常包含类的声明、函数原型、宏定义等信息，用于向其他源文件提供接口和声明。源文件则包含类的实现、函数的具体实现等代码。头文件和源文件之间的关联性体现在头文件被源文件包含，从而使得源文件可以使用头文件中的声明和接口。--AI

数据类型

char      //字符数据类型       short    //短整型       int   //整型（%d）      long   //长整型    long long  //更长的整型     float（%f）   //单精度浮点数   double（%lf）   //双精度浮点数

计算机中的单位

bit-比特位

byte-字节=8bit

kb-1024byte

mb-1024kb

gb-1024mb

tb-1024gb

pb-1024tb

tip1：sizeof-关键字-操作符-计算机类型或变量所占空间的大小

tip2："short"所占的字节大小为2byte，“int”为4byte，那为何“long”所占大小也为4byte呢？--因为c语言标准中sizeof（long）>=sizeof(int)

常量-不能改变的量

变量-能够改变的量

变量的分类（局部变量和全局变量）tip：当局部变量名字与全局变量名字冲突时，局部优先。

//全局变量-{}外部定义

int a=10;

int mian(){

//局部变量-{}内部定义

int a=10;

return 0

}

变量的作用域和生命周期

作用域：一段程序中所用到的名字并不总是有效/可用的，而限定这个名字的可用性的代码范围就是这个名字的作用域。tips：局部变量的作用域是变量所在的局部范围，全局变量的作用域是整个工程。

插个题外话，本人在学习到变量上手码代码试图理解全局变量和局部变量时，分两个源文件使用extern int发现dev的编译器无法成功编译，而VS就可以，也可能由于是新手也不太明白，但看网上都是使用vs的居多，无论怎样，从这方面来看，还是建议大家使用vs更好一点吧。

生命周期：变量的创建和销毁之间的时间段

局部变量的生命周期：进入局部范围生命开始，出局部范围生命结束。

全局变量的生命周期：程序的生命周期。

常量

1.字面常量

"3.14" //浮点常量
"10"  //整数常量
"a"  //字符常量
"abdefg"  //字符串常量

2.const修饰的常变量

补充：const函数用于声明一个常量，其值在声明后不能被修改。确保程序的数据在运行过程中保持不变，避免在代码中不经意间修改常量导致错误的发生。

const int num=10；  //num就是常变量，具有常属性（不能被改变的属性）
int arr[10]={0}；  //10个元素
//
const int n=10;
int arr2[n]={0}；  //读错，因为n是变量

3.#define定义的标识符常量

#define max 10000;
int n=max;  //max不可修改
printf("%d\n",n)  //输出结果n为10000

4.枚举常量

可以一一列举的常量

enum sex{
          male=3;  //将male赋初值     
          female;
          secret;}
int main(){
enum sex s=male;
printf("%d\n",male);  //输出结果为0，赋初值为3
printf("%d\n",female);//输出结果为1，赋值后为4
printf("%d\n",serct); //输出结果为2，赋值后为5
return 0;}

字符串

由双引号引起来的一串字符称为字符串字面值，或简称字符串。

tips：字符串的结束标志是一个\0的转义字符。在计算字符串长度的时候\0是结束标志，不算作字符串内容。

求字符串长度

int len=strlen("abc");
printf("%d\n",len); //调试结果为3

tips：若出现strlen未定义则设置头文件<string.h>

转义字符

意为转变了它原来的意思

\?--在书写连续多个问号时使用，防止他们被解析成三字母词。

\'--用于表示字符常量'

\"--用于表示一个字符串内部的双引号

\\--用于表示一个反斜杠，防止他被解析为一个转义序列符

\a--警告字符，蜂鸣

\b--退格符

\f--进纸符

\n--换行

\r--回车

\t--水平制表符

\v--垂直制表符

\ddd--ddd表示1-3个八进制的数字，如：\130 x

\xdd--dd表示2个十六进制数字。如：\x30 0

注释--用来解释复杂代码

//int a=10  //C++注释风格
/*
int b=10
*/          //c语言注释风格--但不支持嵌套注释

选择语句

int a=0; //输入的值
scanf("%d",&a);
if(a==1){
printf("yes\n");
}
else{
printf("no\n");
}

循环语句

先画个流程图大概了解一下

下面以代码形式展示

int line=0;  //输入值
while(line<10){
printf("继续%d\n",line); //打印并标出序号换行
line++;
}
if(line==10){
printf("over\n");
}

下面介绍几个循环语句（后面会详细描写）

while语句

for语句

do...while语句

函数

int Add(int x,int y){
int z=0;
z=x+y;
return z;
}

int main(){
int num1=0;
int num2=0;
scanf("%d%d",&num1,&num2);
int Sum=Add(num1,num2);
printf("%d\n",Sum);
return 0;
}

数组--一套相同类型元素的集合

int arr[10]={1,2,3,4,5,6,7,8,9,10}；  //定义一个整形数组，最多放十个元素
char ch[5]={'a','b','c'};  //不完全初始化，剩余的默认为0 

tips：数组是用下标来访问的

如图操作符

算术操作符：+   -   *   /   %

int a=9/2;
printf("%d\n",a); //a=4

float a=9/2.0;
printf("%f\n",a); //a=4.5

int a=9%2;
printf("%d\n",a); //a=1

移位操作符： >>      <<

左移运算符--移动的是二进制位 例如代码

int main(){
int a=2;
int b=a<<1;
printf("%d\n",b);  //计算结果应该为4
return 0;
}

 a-2，众所周知，整型中，a占4个字节，也就是32个bit位，在机器语言中写为

00000000000000000000000000000010

 而左移一位后，则第一位删去，最后一位补0，写为

00000000000000000000000000000100

1往前了一位，换算到10进制则为2^2,结果为4

位操作符：&  ^  |

&--按位与     |--按位或    ^--按位异或

   赋值操作符：=     +=    -=   *=    /=    &=   ^=     |=    >>=    <<=

  单目操作符：（a+b，+有两个操作数，双目操作符。只有一个操作数为单目操作数）

！---逻辑反操作

// 0表示假，非0表示真
int a=0；
printf("%d\n",!a);  //值为1

int a=10；
printf("%d\n",!a);  //值为0

if(a){
  //如果a为真，执行
}
if(!a){
  //如果a为假，执行
}

-  ---负值

+ ---正值

& ---取地址

sizeof ----操作数的类型长度（以字节为单位）

int a=10;
printf("%d\n",sizeof(int)); //值为4，且括号里为类型时，括号不可省略
printf("%d\n",siezof a); //值为4，括号里为变量时，括号可以省略

~ ---对一个数的二进制按位取反

#include<stdio.h>
int main(){
int a=0;
//~按位取反
printf("%d\n",~a);  //值为-1
return 0;
}

按（二进制）位取法--把所有二进制位中数字，1变成0,0变成1。

00000000000000000000000000000000   a

1111111111111111111111111111111111111   ~a

tips:整数在内存中储存的是补码,一个整数的二进制表示有三种，即原码，反码，补码

以-1为例：

1000000000000000000000000000001（原码）

11111111111111111111111111111111110（反码）（符号位不变，其他位按位取反）

11111111111111111111111111111111111 （补码）（反码+1）

注：在正整数中，原码，反码，补码相同

-- ---前置，后置--

++  ---前置，后置++

int main(){
int a=10;
int b=++a; //前置++，先前置后使用
printf("%d\n",b) //值为11
printf("%d\n",a) //值为11


int a=10;
int b=a++; //后置++，先使用，在++
printf("%d\n",b); //值为10
printf("%d\n",a); //值为11
return 0;
}

* ---间接访问操作符（解引用操作符）

（类型） ---强制类型转换

int a=3.14;
//强制类型转换
int a=(int) 3.14; //浮点型强制转换为整型

逻辑操作符

&& 并且

||   或者

int a=10;
int b=5;
int c=a&&b; //a和b都为真
printf("%d\n",c); //值为1，假为0

int a=10;
int b=0;
int c=a||b; //a或b有一个为真
printf("%d\n",c); //值为1，假为0

条件操作符（三目操作符）

exp1？exp2:exp3 

exp1成立，exp2计算，整个表达式的结构是：exp2的结果

exp1不成立，exp3结算，整个表达式的结构是：exp3的结果

int a=0;
int b=3;
int max=0;
max=a>b?a:b;
printf("%d\n",max); //值为3

逗号表达式--逗号隔开的一串表达式

exp1,exp2,exp3,......,expN

int a=0;
int b=3;
int c=5;
int d=(a=b+2,c=a-4,b=c+2);
printf("%d\n",d); //值为3
//逗号表达式，是从左往右依次计算
//整个表达式的结果是最后一个表达式的结果

下标引用，函数调用和结构成员

[ ]                  ( )         .      ->

int arr[10]={1,2,3,4,5,6,7,8,9,10}
printf("%d\n",arr[5]);  //值为6，[]，下标引用操作符


printf("hydod\n"); //调用函数时，函数名后边的()就是函数调用操作符

常见关键字

特点

1. C语言提供的，不能自己创建关键字
2. 关键字不能做变量名（不能定义）

以下提供一些常见的关键字

auto      break      case    char   const   continue    default    do     double   else    enum   extern   float    for  goto   if     int   long   register   return   short   signed    sizeof   static  struct   switch     typedef   union  unsigned  void   volatile   while     

auto--是自动的，每个局部变量都是auto修饰的

int main (){
int a=110;   //自动创建，自动销毁-自动变量
//auto省略掉了
return 0;
}

 extern--是用来申明外部符号的

register--寄存器关键字

tips：计算机中的数据可以存储到哪里呢？

寄存器 （更小）——高速缓存（几十MB）——内存（8G，16G）——硬盘（500G）——网盘（2T）

以上，左边造价最高，速度最快，依次递减 ，但空间越小

形成这样的原因大概讲一下，在计算机中处理数据的是中央处理器（CPU），早期其读写数据是从内存中拿取，但后来CPU性能越来越高，内存跟不上CPU的读取速度，导致CPU部分处于闲置状态，所以后来在内存条之上再提出高速缓存和寄存器，CPU读取时从寄存器中读取，寄存器再从高速缓存中读取，高速缓存再从内存中读取，所以越往上速度越快，也就能更高发挥CPU性能

static--静态的

union--联合体（共用体） 

注意，define不是关键字，是预处理指令

          include也不是关键字

typedef--类型重定义

typedef unsigned int u_int;

int main(){
unsigned int num=100;
u_int num2=200  //二者类型相同
return 0;
}

static--静态的

1.static修饰局部变量     2.static修饰全局变量    3.static修饰函数

static修饰局部变量，改变了局部变量的生命周期（本质上改变了变量的存储类型）

栈区——存储的是局部变量和函数的参数

堆区——存储的是动态内存分配的

静态区——存储的是全局变量，static修饰的静态变量

void test(){
int a=1;
a++;
printf("%d",a);  //调试结果为2 2 2 2 2 2 2 2 2 2
}

int main(){
int i=0;
while(i<10){
test();
i++;
}
return 0;
}



void test(){
static int a=1;  //调试结果为2,3,4,5,6,7,8,9,10,11
a++;
printf("%d",a);
}

int main(){
int i=0;
while(i<10){
test();
i++;
}
return 0;
}

tips：static修饰的全局变量只能在自己所在的源文件（.c）内部可以使用，其他源文件不能使用

这里给大家解释一下，全局变量，在其他源文件内部可以使用，是因为全局变量具有外部链接属性，但是被static修饰后，就变成了内部链接属性，其他源文件就不能链接到这个静态的全局变量了。

同样的，static修饰函数，使得函数只能在自己所在的源文件内部使用。本质上，static是将函数的外部链接属性变成了内部链接属性（和static修饰全局变量一样）

#define定义常量和宏

define是一个预处理指令

1.define定义符号

#define Max 1000
int main(){
printf("%d\n",Max)   //1000
return 0;
}

2.define定义宏

#define add(x,y) ((x)+(y))  //宏是有参数的，括号括起来作为一个整体，不严谨地说，宏就是替换
int main(){
printf("%d\n",4*add(2,3));  //结果为20
return 0;
}

指针

在讲指针之前，需要先搞明白两个问题，1.内存是怎么编号的。2. 一个这样的内存单元是多大空间？

在平常生活中，市面上说的计算机机器有32位，64位，这是什么意思呢？

就拿32位说明，32位--32根地址线--物理线--通电，正电为1，负电为0

电信号转换为数字信号，即1和0组成的二进制序列，而编号如下

00000000000000000000000000000000

00000000000000000000000000000001

………………………………

1111111111111111111111111111111111111

共有2^32个序列，当其作为编号后，就将其作为内存单元的地址，也可以说是内存单元的编号

关于第二问题，简单来说，就是一个内存单元占1byte，然后分配地址，即一个字节给一个编号

下面来使用代码简要说明一下指针

int main(){
int a=10; //a在内存中要分配空间的，占4个字节
printf("%p\n",&a);  //%p专门用来打印地址的
int * pa=&a; //pa专门用来存放地址，在C语言中pa叫作指针变量
//*说明pa是指针变量
//int说明pa执行的对象是int类型的

char ch='w';
char * pa=&ch;
return 0;
}

      下面来说明一下解引用操作

int main(){
int a=10;
int * pa=&a;
*pa=20;  //* 解引用操作，* pa就是通过pa里边的地址，找到a
printf("%d\n",a); //结果为20
return 0;
}

换句话说，指针就是地址，使用指针变量的时候，就是使用里边的地址

指针变量的大小

指针大小在64位平台中是8个字节，32位平台是4个字节

原因可以大概解释一下，指针的大小跟地址线的多少有关，而地址线又跟32位或64位平台有关 ，所以地址线不同，字节大小也就不同

结构体

即使C语言有能力描述复杂类型，下面用代码形式来看看其使用格式

tips：在结构体中也可以使用指针来解引用地址，不过也要注意顺序和格式 

众所周知，C语言是结构化的程序设计语言，它包含的结构体有--顺序结构，选择结构，循环结构

以下重点讲选择结构中的分支语句（if 、switch）以及循环结构中（while、for、do while）

首先，什么是语句？--即C语言中有一个分号；隔开的就是一个语句，如

printf（"lyb"）;
6+5;
; //这是一个空语句

 if语句

语法结构

在表达式中，条件如果为真（非零）--执行，为假则不执行

if(表达式)
  语句；

if(表达式)
  语句1；
else
  语句2；

// 多分支
if(表达式1)
  语句1；
else if(表达式2)
  语句2；
else
  语句3；

下面来举个例子

int main(){
int age=18;
if(age>=18)
printf("成年");
else
printf("未成年"); //输出结果，成年
return 0;
}

 在日常学习if语句时，有两个常见的错误，同样以代码形式展开

int a=20;
if(a>=18)
  printf("成年\n");
else
  printf("未成年")；
  printf("不能谈恋爱"); //输出结果是成年
                        // 不能谈恋爱    

这样的输出结果显然与我们本意是相悖的，成年人当然可以谈恋爱，但为什么会出现这样的结果，是因为if语句中默认情况下只会控制一条输出语句，如果你想要控制多条输出语句，则需要加{}，如下图

else{
printf("");
printf("");
}

第二种错误是这样的

int age=60;
if(age<18)
  printf("未成年");
else if(18<=age<26)
  printf("青年")； //输出结果为青年

 这样的结果显然是错误的，60岁怎么会是青年呢？实际上，这并不是语法错误，而是逻辑错误，在18<=age,该结果判定为真，即值为1，而1<60为真，则执行语句，所以才会出现以上结果。

正确书写方式应该是以下形式

else if(age>=18 && age<26)
   printf(" ");

下面来讲一个非常容易搞错的问题，叫悬空else ，下面先以代码形式展开

int main(){
int a=1;
int b=2;
if(a==0)
  if(b==2)
    printf("ok\n");
else
  printf("sorry\n"); //程序运行后不打印
return 0;
}

相信会有人认为最后的打印结果应该是sorry，因为常规思路是a==0为假，执行else语句，其实不然，在c语言中，else只与离他最近的if产生连接关系，所以在该程序中，a==0为假后，直接返回到return 0，并不会打印。

switch语句

switch语句常用于多分支，接下来用代码形式展示

int main(){
int day=0;
scanf("%d",&day);
switch(day){
case1:
   printf("星期一\n");
   break;
case2;
   printf("星期二\n");
   break;
case3;
   printf("星期三\n");
   break;
case4;
   printf("星期四\n");
   break;
case5;
   printf("星期五\n");
   break;
case6;
   printf("星期六\n");
   break;
case7;
   printf("星期天\n");
   break;
}
return 0;
}

同样的，break语句也可以根据语境来删除

int main(){
int day=0;
scanf("%d",&day);
switch(day)
case 1:
case 2:
case 3:
case 4:
case 5:
     printf("工作日\n");
     break;
case 6:
case 7:
     printf("休息日\n");
     break;
return 0;
}

当然，如果你数入的数值里并不是1-7时该怎么办，这时候就要引出default语句来完善程序结构，如下图 

int main(){
int day=0;
scanf("%d",&day);
switch(day)
case 1:
case 2:
case 3:
case 4:
case 5:
     printf("工作日\n");
     break;
case 6:
case 7:
     printf("休息日\n");
     break;
default:
     printf("程序错误");
     break;
return 0;
}

while循环语句 

在while循环中，break用于永久的终止循环，continue的作用是跳过本次循环continue后面的代码，直接去判断部分，看是否进行下一次循环。

下面用代码展示while循环，例，打出数字1-10

int main(){
int i=1;
while(i<=10){
printf("%d\n",i);
i++;
}
return 0;
}

getchar() 

含义为读取字符从标准输入中，即键盘，下面先展示代码

int main(){
int ch=0;
while((ch=getchar())!=EOF){
   putchar(ch);
}
return 0;
}

while括号内的语句解释为，将键盘输入的字符赋给ch，ch并没有报错，下面的putchar()意为将ch打印出来，与printf类似。

这里解释一下EOF，全称为end of file，为文件结束标志。

需要补充的是，当你在输入时按下Ctrl+Z，相当于getchar读取结束

下面来解释一个getchar（）常见的错误案例，老规矩，先看代码

可以看见，我们并未进行确认密码的操作，但系统自动反馈成了确认失败，这是为什么呢？这里简单解释一下，我们键盘输入的数据会先存入到缓冲区，然后scanf（），getchar（）从缓冲区拿取数据，输入完密码敲一下回车执行scanf（），但此时缓冲区里存放的数据为132456\n，scanf拿取123456，但此时还有\n，轮到getchar（）执行时会发现缓冲区中还有数据，便会直接读取了，所以系统会直接反馈。

既然知道了问题所在，那么解决方法是什么呢，很简单，就是清理缓冲区，代码如下图。

int main() {
	char password[20] = { 0 };
	printf("请输入密码:>");
	scanf("%s", password);
	printf("请确认密码(Y/N):>");
    // 清理缓冲区
    getchar(); 
	int ch = getchar();
	if (ch == 'Y') {
		printf("确认成功");
	}
	else {
		printf("确认失败");
	}
	return 0;
}

但考虑实际情况往往会更加复杂，如果密码中间多了一个空格，结果又会如何？ 

尽管进行了清理缓冲区，但系统仍然自动报错，这是为什么呢？这是因为scanf只读取了空格前面的数据，而getchar只清理了一个字符，但缓冲区中仍有多个字符，所以下面代码识别便会出现错误，此时解决的方法就要用到while循环，如下图 

这样一来，问题才算真正解决。 

 for语句

for语句的基本格式为for(表达式1；表达式2；表达式3){} 

下面先给各位提一些关于for循环的建议

1.不可在for循环内修改循环变量，防止for循环失去控制

int main(){
int i = 0;
for(i=0;i<11;i++){
printf("%d\n",i);
i = 5;  //局内修改变量，会导致代码陷入死循环，持续输出6
}
return 0;
}

2.建议for语句循环控制变量的取值采用“前闭后开区间”写法

关于for循环的两个变种

int main(){
for( ; ; ){
printf("hehe\n");
}
return 0;
}

int main(){
int x,y
for(x=0,y=0;x<2 && y<5; ++x,y++){
printf("hehe\n");
}
return 0;
}

do while语句 

特点：循环至少执行一次，使用的场景有限，并不经常使用

下面来展示其基础代码

#include<stdio.h>
int main()
{
  int i=10;
  do
    {
       printf("%d\n",i);
    }while(i<10);
return 0;
}

关于在该循环中的continue和break

int i =10;
do
{
 if(5 == i)
    break; //直接终止该循环，但并不会终止整个程序的循环
 printf("%d\n",i);
}while(i<10);

 下面来做一个比较有意思的一个例题

题目是如何在一个有序数组中查找具体的某个数字n ？

比较快捷的方法就是使用折半查找，也可以称作二分查找

下面进行具体的代码介绍

#include<stdio.h>
int main()
{
	int arr[] = { 1,2,3,4,5,6,7,8,9,10 };
	int k = 7;  //要查找的数字
	int sz = sizeof(arr) / sizeof(arr[0]); //数组的元素个数
	int left = 0;
	int right = sz - 1;
	while (left <= right)
	{
		int mid = (left + right) / 2;
		if (arr[mid] < k)
		{
			left = mid + 1;
		}
		else if (arr[mid] > k)
		{
			right = mid - 1;
		}
		else
		{
			printf("找到了，下标是:%d\n", mid);
			break;
		}
	}
	if (left > right)
	{
		printf("找不到了\n");
	}
	return 0;
}

 tip：代码中left与right分别为数组中两端的下标。(代码内容不尽详述，若何处有误解欢迎留言)

还有一个比较有趣的代码，下面来给大家展示一下

#include<stdio.h>
#include<string.h>
#include<windows.h>
int main() 
{
	char arr1[] = "welcome to the world";
	char arr2[] = "####################";
	int left = 0;
	int right = strlen(arr1) - 1;
	while (left <= right)
	{
		arr2[left] = arr1[left];
		arr2[right] = arr1[right];
		printf("%s\n", arr2);
		Sleep(1000);//代码运行缓慢1000毫秒
		system("cls");//清空屏幕
		left++;
		right--;
	}
	printf("%s\n",arr2);
	return 0;
}

当使用strlen（）是开头要补上头文件<string.h>

当使用Sleep（）（注意开头大写）以及system（"cls"）时开头要补<windows.h>

下面来再进行一个例题

编写代码实现，模拟用户登录情景，并且只能登录三次。（只允许输入三次密码，如果密码正确则提示登录成功，如果三次均输入错误，则退出程序。）

老规矩，先展示代码

#define	_CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
#include<stdlib.h>
#include<time.h>

void menu()
{
	printf("**********************\n");
	printf("***** 1.play *********\n");
	printf("***** 0.exit *********\n");
	printf("**********************\n");
}

void game()
{
//猜数字游戏的实现
//1.生成随机数
	//rand函数返回了一个0-32767之间的数字
	//时间 - 时间戳
	int ret = rand() % 100 + 1; //%100的余数是0-99，然后+1，范围就是1-100
		//2.猜数字
	int guess = 0;
	while (1)
	{
		printf("猜猜数字:>");
		scanf("%d", &guess);
		if (guess < ret)
		{
			printf("猜小了\n");
		}
		else if (guess > ret)
		{
			printf("猜大了\n");
		}
		else
		{
			printf("恭喜你，猜对了\n");
			break;
		}
	}
}
int main()
{
	int input = 0;
	do
	{
		menu(); //打印菜单
		printf("请选择:>\n");
		scanf("%d", &input);
		switch (input)
		{
		case 1:
			game();
			break;
		case 0:
			printf("退出游戏\n");
			break;
		default:
			printf("选择错误，重新选择\n");
			break;
		}
	} while (input);
	return 0;
}

tips：strcmp（）函数，用法如下，将输入的密码与“123456”进行比较，（使用strcmp函数是要使用string头文件）

strcmp（password，“123456”==0） 

函数 

-----------------------------------------------待续---------------------------------------------------------------