C++学习笔记

数据类型

数据类型转换

• 自动类型转换

  • 数据由小范围到大范围

• 强制类型转换

  • 数据范围由达大到小可能会发生数据丢失

运算符

三目运算符

**语法**
表达式1?表达式2:表达式3

**例子**
#include <iostream>
using namespace std;
int main ()
{
	double a = 0,b = 0,c = 0;
	cout<<"请输入数字a，b进行比较:"<<endl;
	cin>>a>>b;
	c = ((a>b)?a:b); //三目运算返回值为变量，可以继续赋值运算。
	cout<<endl<<"a，b比较大的为:"<<c<<endl<<endl;
	return 0;
}

选择结构和常用关键字

Switch语句

执行多条条件分支语句

控制关键字辨析

关键字	用法
return（返回）	跳出循环，返回得到值，用于进行下面的运算 。
break（打破）	跳出循环或内层循环。
continue（延续、继续）	结束本次循环，进行下次循环。
go to	代码传送

break

例子

#include <iostream>
using namespace std;

int main ()
{
	for (int i = 0; i <= 9; i ++)
	{
		for (int j = 0; j <= 9; j ++) 
		{
			cout<<"*  ";
			if (j == i) break;//跳出内层循环
		}
		cout<<endl;
	}
	int k = 9;
	
	while (k --)
	{
		for (int j = 0; j <= 9; j ++) 
			{
				cout<<"*  ";
				if (j == k) break;
			}
		cout<<endl;
	}
	return 0;
}

continue

例子

go to

从go to语句传送到标记处

例子

#include <iostream>
using namespace std;
//不推荐使用，可读性不强。
int main ()
{
	cout<<"1";
	cout<<"2";
	cout<<"3";
	goto lalala;
	cout<<"4";
	cout<<"5";
	cout<<"6";
	cout<<"7";
	lalala:
	cout<<"8";
	cout<<"9";
	cout<<"10";
	cout<<"111";
	return 0;
}

语法

switch (表达式)
{
  case 结果1:
    {
      操作1；
    }
  	break;
  case 结果2: 
  case 结果3:
    {
      操作2；
    }
    break 3;
}

例子

电影评分
#include <iostream>
using namespace std;

int main ()
{
	int se;
	cout<<"请给电影打1~10分！！"<<endl;
	cin>>se;
	switch (se)//判断表达式只能是整型或字符型，不可是一个区间。
	{
		case 2://不写break则向下继续进行，直到运行到return。
		case 1:
			cout<<endl<<"烂！";
			break;//（打破）
		case 3:
		case 4:
			cout<<endl<<"差！";
			break;
		case 5:
		case 6:
			cout<<endl<<"一般";
			break;
		case 7:
		case 8:
		case 9:
			cout<<endl<<"好！";
			break;
		case 10:
			cout<<endl<<"极好的！";
			break;
		default://（默认值），不符合以上条件，返回默认值。
			cout<<endl<<"查无此数据！！！";
			break;
	}
	return 0;
}

数组

特点

​ 1、储存在连续空间中

​ 2、同个数组数据类型相同

一维数组

定义方式

数据类型 数组名 [数组长度]//定义，可使用循环初始化
数据类型 数组名 [数组长度] = {值1,值2,值3,~~~}//定义+初始化
数据类型 数组名 [] = {值1,值2,值3,~~~}//定义+初始化

以上几种定义方法都能确定数组存放数据的最大数量

初始化

意义在于防止内存中的垃圾数据对数组中的数据造成影响。

#include <iostream>
using namespace std;

int main ()
{
	int arr[100];
	for (int i = 0; i < 100 ; i ++) 
	{
		arr [i] = 0;//初始化为“0”。
	}
	return 0;
}

一维数组的操作

• 计算数组长

  使用sizeof（运算符）操作

  #include <iostream>
  using namespace std;
  
  int main ()
  {
  	int arr[100];
  	for (int i = 0; i < 100 ; i ++) 
  	{
  		arr [i] = 0;
  	}
  	cout<<"整个数组占内存长度："<<sizeof(arr)<<endl;
  	cout<<"数组中首个数据占内存大小："<<sizeof(arr[0])<<endl;
  	cout<<"数组中元素个数："<<sizeof(arr)/sizeof(arr[0])<<endl;
  	return 0;
  }
  

• 查看数组地址

  #include <iostream>
  using namespace std;
  
  int main ()
  {
  	int arr[100];
  	for (int i = 0; i < 100 ; i ++) 
  	{
  		arr [i] = 0;
  	}
  	cout<<"使用数组名查看数组首地址（16进制）："<<arr<<endl;
  	cout<<"使用数组名查看数组首地址（10进制）："<<(long)arr<<endl;
  	cout<<"直接查看数组首地址（16进制）："<<&arr[0]<<endl;
  	return 0;
  }
  

二维数组

二维数组概念上是二维的，实际在硬件中是连续编址的

数组可分段赋值和连续赋值

应用

经典使用方法

元素逆置

冒泡排序

printf格式化输出

语法

printf("语句1,语句2",参数1,参数2)
  注：
  	1、语句与参数位置一一对应
  	2、语句中包含直接显示的内容、格式化符、转义符

函数

函数的声明、定义、调用

https://www.runoob.com/cplusplus/cpp-functions.html

函数的传值方式

值传递

引用传递

指针传递

函数的分文件编写

可以分别分开函数的声明、定义、调用环节，达到分文件编写的目的

总结:头文件中的 声明 了函数的 定义 和主函数的 调用

// 1.新建头文件(XXX.h);新建C++文件(XXX.cpp)
// 2.XXX.h写自定函数用到的 头文件 和 函数的声明;XXX.cpp写 函数的定义 并引入 声明的头文件
// 3.自定函数的调用:直接引入自定义的头文件即可使用



//===== (sum.h)自定义的头文件内容 ===== 

#include <stdio.h>
using namespace std;

int sum(int a, int b);

//===== (sum.cpp) 自定义的函数内容 =====

#include "sum.h"
int sum(int a, int b)
{
    return (a + b);
}

//===== 调用函数的文件 =====

#include <iostream>
#include"sum.cpp"
using namespace std;
int main()
{
    int x;
    int y;
    cin>>x>>y;
    cout << sum(x, y) << endl;

    return 0;
}

静态变量static的性质

在函数体内，静态变量具有 “记忆”功能，即一个被声明为静态的变量在这一函数被调用的过程中其值维持不变；使用时需注意他的作用域，它的作用域范围是有限制的。

指针

32位系统下指针占4字节，63位系统下指针占8字节。

指针的定义、赋值、使用

#include <iostream>
using namespace std;

int main()
{ // 记忆方式
  // *p 表示指针指向的内存的内容
  // p 表示指针指向的内存地址
    int a = 188;
    int *p = &a; //定义+赋值
		
  	int *q; //定义
    q = &a; //赋值	
  
  	int *v = NULL;//指向地址为0的指针，初始化；

    
    return 0;
}

空指针、野指针

#include <iostream>
using namespace std;

int main()
{ //空指针
		int *v = NULL;//指向地址为0的空指针，用于初始化。

#include <iostream>
using namespace std;

int main()
{ //野指针
    int *p =NULL; //定义+赋值

    p = (int *)0x1100;//强制存入一个地址
    cout << *p;//非法输出，禁止访问
    return 0;
}

const(常量) 修饰指针

指针常量、常量指针、常量指针指向常量

#include <iostream>
using namespace std;

int main()
{
    int a = 110;
    int b = 123;
    //常量指针:存储的内容是常量
    const int *p;

    *p = 220; //错误!
    p = &b;   //正确

    //指针常量:指针的地址是常量
    int *const q = &a;

    *q = 220; //正确
    q = &b;   //错误!

    //常量指针指向常量:内容和指针的地址均是常量
    const int *const r = &a;

    *r = 220; //错误!
    r = &b;   //错误!

    return 0;
}

指针与数组、函数的关系实例

通过指针改变数组的值

#include <iostream>
using namespace std;

int main()
{//通过指针改变数组的值

    int arr[10] = {0};
    int *p = arr;//指针指向数组首元素地址
    for (int i = 1; i < 11; i++)
    {
        *p = i;//通过指针更改数组中的值
        p ++;//地址+1等同于向后移动4位   
        printf("%d\n",arr[i-1]);
    }
    
    return 0;
}

指针与数组的相互转化

#include <iostream>
using namespace std;

int main()
{ //数组与指针的关系
  // 重要结论:指针p指向数组首元素地址时，*(p+i)可写成 p[i] =arr[i]
  // 当指针指向数组首地址时,相当于指向整个数组
    int *p;
    int arr[10] = {13, 4356, 37, 65, 432, 53, 7, 5, 4, 56};
    p = arr; //指针指向数组首地址
    for (int i = 0; i < 10; i++)
    {
        cout << p[i] << endl;
    }

    return 0;
}

函数的地址传递

#include <iostream>
using namespace std;

void Swap(int *a ,int *b);//交换函数

int main()
{//函数地址传递交换两个数
    int x;
    int y;
    cin>>x>>y;
    Swap(&x,&y);//传入x,y地址
    printf("x = %d\ny = %d\n",x,y);
    return 0;
}

void Swap(int *a ,int *b){
    int count = *a;
    *a = *b;
    *b = count;
}

使用函数对整型数组进行升序冒泡排序

#include <iostream>
using namespace std;

//第一种写法===============================================
void Sort(int *q); //传入数组首地址
int length;//全局变量,不安全

int main()
{

    int arr[10] = {13, 4356, 37, 65, 432, 53, 7, 5, 4, 56};
    length = sizeof(arr) / sizeof(arr[0]);
    Sort(arr);
    for (int i = 0; i < length; i++)
    {
        cout<<arr[i]<<endl;
    }

    return 0;
}

void Sort(int *q)//函数过于复杂
{
    for (int i = 0; i < length; i++)
    {
        for (int j = 0; j < length - i - 1; j++)
        {
            if (*(q + j) > *(q + j + 1))
            {
                int count = *(q + j);
                *(q + j) = *(q + j + 1);
                *(q + j + 1) = count;
            }
        }
    }
}

//第二种写法=================================================
void Sort(int *q, int length); //传入数组首地址和数组长度

int main()
{
    int arr[10] = {13, 4356, 37, 65, 432, 53, 7, 5, 4, 56};
    int length = sizeof(arr) / sizeof(arr[0]);
    Sort(arr, length);
    for (int i = 0; i < length; i++)
    {
        cout << arr[i] << endl;
    }

    return 0;
}

void Sort(int *q, int length) //数组为地址传递
{
    for (int i = 0; i < length; i++)
    {
        for (int j = 0; j < length - i - 1; j++)
        {
            if (q[j] > q  [j + 1]) 
            {//指针指向数组首地址,相当于指向整个数组!
                int count = q[j];
                q[j] = q[j + 1];
                q[j + 1] = count;
            }
        }
    }
}

结构体

结构体的定义、创建结构体变量、赋值、调用

结构体数组、结构体做函数参数

指针访问结构体

将指针指向结构体首元素，使用“->”可访问结构体元素内容

#include<iostream>
using namespace std;
int main(){
    struct AL{
    int a;
    char b;
    };
    AL  ss={555,'*'};

    //创建结构体类型指针
    AL *t;
    //指向结构体首地址
    t = &ss;
    //通过指针改变结构体内容
    t->a = 99;//等效于(*t).a =99
    (*t).b = 'a';
    return 0;
}

其他

内存的分配与释放

未整理

https://blog.csdn.net/henulwj/article/details/8234365

内存分区模型(四区域)

代码区、（程序运行前）

• 储存二进制的代码，由系统进行管理。

• 代码区特点

  • 共享：对于频繁执行的程序，内存中只保留一份即可。
  • 只读：防止程序意外修改。

全局区(程序运行前)

• 全局区特点：程序结束后由系统控制释放。
• 储存内容
  • 变量
    • 全局变量(非函数内)
    • 静态变量(static修饰)
  • 常量
    • 字符串常量(即双引号引起的内容)
    • const修饰变量(const修饰的全局变量，即为全局常量,不包括const修饰的局部变量)

栈区(程序运行后)

• 储存
  • 局部变量**——不要返回局部变量，易产生非法操作**待完善！
  • 函数中参数
• 由编译器分配释放，函数调用结束后释放。

堆区(程序运行后)

• 由程序员分配释放，程序结束后操作系统回收。

• new运算符

  开辟一块内存空间，返回首地址

  int *a = new int (500);//括号内为数据
  int *b  =new int[10];//开辟一个数组
  

• delete关键字

  释放一片内存

内存分区模型代码示例

C++中的引用

可看做是给一个变量起别名，实质引用变量是指针常量(地址不可变，内容可变)

int a =10;
int &b = a;//等效于  int *const b =a;
b = 99;//等效于 *b = 99；

引用变量做函数返回值

引用局部变量时需注意待完善！