C++笔记

Per Aspera Ad Astra

已于 2023-12-23 21:48:13 修改

阅读量1k

点赞数 23

文章标签： c++ 笔记开发语言

于 2023-12-23 15:55:48 首次发布

本文链接：https://blog.csdn.net/weixin_62559038/article/details/135159233

版权

7.5.3const既修饰指针，也修饰常量

一.建立c++工程

1.建立项目

选择c++，
选择windows，
选择控制台，
最后点击空项目
点击下一步
项目命名和保存路径

2.创建源文件

1.在源文件处右键选择添加选择新建项并且命名

3.c++代码初始模板

#include <iostream>
using namespace std;

int main()
{

	system("pause");

	return 0;
}

二.基本语言

2.1.注释

2.1.1单行注释

// 通常放在一行代码的上方，对该行做注释

2.1.2单行注释

/* 对该段做注释 */

2.2.变量

作用：给一段指定的内存空间起名，方便操作管理这段内存

语法：数据类型变量名 = 初始值；

#include <iostream>
using namespace std;

int main()
{
	int a = 5;

	cout << "a=" << a << endl;

	system("pause");

	return 0;
}

2.3.常量

作用：用于记录程序中不可更改的数据

有两种方式

2.3.1.#define 宏变量

语法：#define 常量名常量值

文件上方定义，表示一个常量，不可修改

2.3.2.const修饰的变量

语法：const 数据类型常量名 = 常量值

在变量定义前加关键字const，修饰变量为一个常量，不可修改

#define pi 3

const int a = 15;

2.4.关键字

作用：c++中预先保留的单词(标识符)

在定义常量或变量时，不能使用关键字

2.5.命名规则

作用：给标识符(变量，常量)命名时，有自己的规则

标识符不能是关键字
第一个字符必须是字母或下划线
标识符只能由字母，数字，下划线组成
标识符中字母区分大小写

	int a = 5;
	int _123 = 6;
	int _156g = 6;

2.6.数据类型

规定一个变量和常量时，要指出相应的数据类型，否则无法给变量分配内存

给变量分配合适的内存空间

2.6.1.整型

作用：表示的是整形数据的数据

整型也分为好几种类型，各自所占的内存空间不同

1字节 = 8bit

8bit可用1个16进制表示

0x01 = 0000 0001 2^7次方-1

2字节 = 16bit

0x0001 = 0000 0000 0000 0001 2^15次方-1

	short     a = 5;
	int		  b = 6;
	long      c = 6;
	long long d = 7;

	cout << "a=" << sizeof(a) << endl;
	cout << "b=" << sizeof(b) << endl;
	cout << "c=" << sizeof(c) << endl;
	cout << "d=" << sizeof(d) << endl;

2.6.2.sizeof关键字

作用：利用sizeof统计数据类型所占内存大小

语法：sizeof( 数据类型) sizeof(变量)

2.6.3.实型(浮点型)

作用：表示小数

浮点型变量分为两种（区别在于表示的有效数字范围不同）：

单精度float
双精度double

	float     a = 5.16f;
	double	  b = 6.48915615615;


	cout << "a=" << a << endl;
	cout << "b=" << b << endl;

通常在float 定义的变量初始值后面加上f，不加的话编译器默认认为变量为double类型，多一步将double类型转换为float类型的步骤。

默认情况下，输出一个小数，会显示6位有效数字。

2.6.3.1.科学计数法

	float     a = 3e2; // 3 * 10 ^ 2
	double	  b = 3e-2;// 3 * 10 ^-2


	cout << "a=" << a << endl;
	cout << "b=" << b << endl;

2.6.4.字符型

作用：用于显示单个字符

语法：char ch = ‘a’；

注意：

用单引号将字符括起来，不是用双引号
单引号内只能有一个字符，不可以是字符串
只占用一个字节
不是把字符本身放在内存中存储，而是将其对应的ASCII编码的值放在存储单元

ASCII编码表

	char a = 'c';

	cout << "a=" << a << endl;
	cout << "十进制" << int(a) << endl;
	cout << "大小" << sizeof(a) << endl;

2.6.5.转义字符

作用：用于表示一些不能显示的ASCII字符

	cout << "aaaa\thello" << endl;
	cout << "aaaaaa\thello" << endl;
	cout << "a\thello" << endl;

2.6.6.字符串型

作用：表示一串字符

注意：

用的是双引号而不是单引号

2.6.6.1.c风格字符串

char 变量名[ ] = " 字符串值"

2.6.6.2.c++风格字符串

string 变量名 = " 字符串值"

用c++风格需要包括 #include <string>

	char a[ ] = "hello world";
	string b = "hello world";
		 
	cout << a << endl;
	cout << b << endl;

2.6.7.布尔类型bool

作用：布尔数据类型代表真或假的值

bool类型只有两个值(内存只占一个字节大小)：

true ---真(本质是1)
false ---假(本质是0)

	bool flag = true;
	cout << flag << endl;

	bool flag2 = 1;
	cout << flag2 << endl;

2.6.8.数据的输入

作用：用于从键盘获取数据

关键字：cin

语法：cin >> 变量

	int a = 2;
	cout << "输入a的值" << endl;
	cin >> a;
	cout << "a=" << a << endl;

三.运算符

作用：执行代码的运算

3.1.算术运算符

作用：处理四则运算

注意：

两个整数相除，结果依然为整数，小数部分去除。
分母不为0。
10 % 20 =10
俩个小数不可以做取模% 运算

3.1.1递增

前置递增-----------------------------先++后运算

先让变量 ++ ，然后再进行表达式运算。

	int a = 2;
	int b = 3;
	b = ++a * b;
	cout << "a=" << a << endl;
	cout << "a=" << b << endl;

后置递增-----------------------------先运算后++

先进行表达式运算，在让变量 ++

	int a = 2;
	int b = 3;
	b = a++ * b;
	cout << "a=" << a << endl;
	cout << "a=" << b << endl;

3.1.2递减

前置递减

先让变量 -- ，然后再进行表达式运算。

后置递减

先进行表达式运算，在让变量 --

3.2.赋值运算符

作用：将表达式的值赋给变量

3.3.比较运算符

作用：用于比较式的比较，并返回一个真值或假值

3.4.逻辑运算符

作用：用于根据表达式的值返回真值或假值

四.程序流程结构

三种程序运行结构：

顺序结构：程序按照顺序执行，不发生跳转
选择结构：依照条件是否满足，有选择的执行相应的功能
循环结构：依照条件是否满足，循环多次执行某段代码

4.1.选择结构

4.1.1 if语句

作用：执行满足条件的语句

三种形式

单行格式if语句
多行格式if语句
多条件的if语句

4.1.1.1 单行格式if语句：

	if (flag)
	{

	}

4.1.1.1.2多行格式if语句

	if (flag)
	{

	}
	else
	{

	}

4.1.1.1.3多条件的if语句

	if (flag)
	{

	}
	else if(flag2)
	{

	}
	else if (flag3)
	{

	}
	else
	{

	}

4.1.2三目运算符

作用：通过三目运算符实现简单的判断

语法：表达式1 ？表达式2 ：表达式3

解释：

如果表达式1的值为真，执行表达式2，并返回表达式2的结果；

如果表达式1的值为假，执行表达式3，并返回表达式3的结果；

c++中三目运算符返回的是变量，可以继续赋值

	int a = 2;
	int b = 3;
	int c = 0;
	int d = 0;

	c = (a > b ? a : b);
	(a > b ? a : b) = 100;
	cout << "c=" << c << endl;
	cout << "b=" << b << endl;

4.1.3switch语句

作用：执行多条件分支语句

语法：

4.2.循环结构

4.2.1.while循环

4.2.2.do...while循环

4.2.3.for循环

4.3.跳转语句

4.3.1 break语句

4.3.2 continue语句

4.3.3 goto语句

作用：可以无条件跳转语句

语法：goto 标记；

解释：如果标记的名称存在，执行到goto语句时，会跳转到标记的位置。

标记不需要被初始化。

五.数组

5.1一维数组

5.1.1一维数组定义

三种定义方式：

数据类型数组名 [ 数组长度] ；
数据类型数组名 [ 数组长度] = { 值1 ，值2 ......}；
数据类型数组名 [ ] = { 值1 ，值2 ......}；

数组元素下标从0开始索引的

	int arr[5];
	arr[0] = 99;
	arr[1] = 5;
	arr[2] = 56;

	int arr2[5] = { 2,6,3,4,5 };
	int arr3[] = { 2,6,3,4,5 };

5.1.2一维数组数组名

	int arr[5];
	cout << "整个数组占用空间大小" << sizeof(arr) << endl;
	cout << "每个元素占用空间大小" << sizeof(arr[0]) << endl;
	cout << "数组元素个数" << sizeof(arr)/ sizeof(arr[0] )<< endl;
	cout << "数组首地址" << arr << endl;
	cout << "数组首地址" << int(arr) << endl;
	cout << "数组第一个元素首地址" << &arr[0] << endl;
	cout << "数组第一个元素首地址" <<int( & arr[0]) << endl;

5.2二维数组

5.2.1二维数组定义方式

四种方式：

数据类型数组名 [ 行数 ] [ 列数 ]；
数据类型数组名 [ 行数 ] [ 列数 ] = { {数据1，数据2} ，{数据3，数据4} }；
数据类型数组名 [ 行数 ] [ 列数 ] = { {数据1，数据2 ，数据3，数据4 }；
数据类型数组名 [ ] [ 列数 ] = { {数据1，数据2 ，数据3，数据4 }；

	int arr1[2][2];
	arr1[0][0] = 0;
	arr1[0][1] = 0;
	arr1[1][0] = 0;
	arr1[1][1] = 0;

	int arr2[2][2] = 
	{   
		{1,2},
		{3,4} 
	};
	int arr3[2][2] = { 1,2,3,4 };
	int arr4[ ][2] = { 1,2,3,4 };

5.2.2二维数组数组名

查看二维数组所占空间
获取二维数组首地址

		int arr2[2][2] = 
	{   
		{1,2},
		{3,4} 
	};


    cout << "二维数组空间大小" << sizeof(arr2) <<endl;
	cout << "二维数组第一行空间大小" << sizeof(arr2[0]) << endl;
	cout << "二维数组第一个元素空间大小" << sizeof(arr2[0][0]) << endl;
	cout << "二维数组行数" << sizeof(arr2) / sizeof(arr2[0]) << endl;
	cout << "二维数组列数" << sizeof(arr2[0]) / sizeof(arr2[0][0]) << endl;
	cout << "二维数组空间首地址" << arr2 << endl;

六.函数

6.1概述

6.2定义

6.3调用

6.4值传递

6.5函数常见样式

4种样式

无参无返
无参有返
有参无返
有参有返

//无参无返
void tset1(void)
{

}
//调用 ： tset1();

//无参有返
int tset2(void)
{
	return 0;
}
//调用 ： tset2();

//有参无返
void tset3(int a)
{

}
//调用 ： tset1(200);

//有参有返
int tset4(int a)
{
	return a;
}
//调用 ： tset4(200);

6.6函数的声明

6.7函数的分文件编写

1.第一步在头文件处新建项选择头文件.h，并且填好名称

2.第二步在源文件处新建项选择c++文件.cpp，并且填好与头文件相同的名称

3.在头文件.h中添加一些引用的头文件和函数声明

#include <iostream>
using namespace std;
#include <string>

void hanshu(int a, int b);

4.在源文件.cpp中添加引用头文件.h的语句外加函数的定义

#include "02.h"


void hanshu(int a, int b)
{
	int temp;

	temp = a + b;

}

七.指针

7.1概念

作用：通过指针间接访问内存

内存编号从0开始记录，一般用16进制数字表示
可以利用指针变量保存地址

7.2定义和使用

语法：数据类型 * 变量名

	int a = 10;
	//定义为指针后存放的是一个地址
	int * p;

	//让p存放a的地址
	p = &a;
	cout << "a地址为" << &a << endl;
	cout << "p为" << p << endl;

	//对p所指定的地址中存放的一个东西做出改变，需要解引用
	*p = 500;
	cout << "a为" << a << endl;
	cout << "p为" << p << endl;

7.3所占用的内存空间

在32位操作系统下，指针是占用4个字节空间大小，不管定义的是什么类型。

在64位操作系统下，指针是占用8个字节空间大小，不管定义的是什么类型。

	cout << "int *   \t " << sizeof(int*) << endl;
	cout << "float * \t  " << sizeof(float *) << endl;
	cout << "long long *\t " << sizeof(long long*) << endl;

7.4 空指针和野指针

空指针：指针变量指向内存中编号位0的空间

用途：初始化指针变量

空指针指向的内存不可以访问

	//        NULL = 0
	int * p = NULL;

野指针：指针变量指向非法的内存空间

7.5const修饰指针

const修饰指针有三种情况：

const修饰指针 --常量指针
const修饰常量 --指针常量
const既修饰指针，也修饰常量

7.5.1常量指针

在指针前面添加const ，即为常量指针

注意：指针的指向可以修改，但是指针指向的值不可修改

const修饰的是*，所以解引用后的值不可以修改

	int a = 10;

	const int* p = &a;

7.5.2指针常量

const 放在数据类型 * 与变量名中间，

即数据类型 * const 变量；

注意：指针的指向不可以修改，但是指针指向的值可以修改

const修饰的是b，所以指向不可以修改

	int* const b = &a;

红色为不可以指向

7.5.3const既修饰指针，也修饰常量

前面与中间均有const

注意：指针的指向和指向的值都不可以修改

	const	int* const b = &a;

红色为不可以指向和修改

7.6指针和数组

作用：利用指针访问数组中的元素

数组与指针的类型要对应，指针在32位操作系统占用4个字节，存放的是数组的地址，当要让指针++也就是存放的地址++，会根据存放数组类型大小(占用的是几个字节)进行++，而不是根据指针类型大小进行++。

	double arr[10] = {1,2,3,4,5,6,7,8,9,10};

	double* p = arr;//arr就是数组首地址

	cout << "第1个元素 " << *p << endl;
	p++;
	cout << "第2个元素 " << *p << endl;

指针遍历数组

	double arr[10] = {1,2,3,4,5,6,7,8,9,10};

	double* p = arr;//arr就是数组首地址

    for (int i = 0; i < 10; i++)
	{
		cout << *p << endl;
		p++;
	}

7.7指针和函数

作用：利用指针做函数的参数，可以修改实参的值

void transmit(int* a, int* b)
{
	int temp = *a;
	*a = *b;
	*b = temp;
}

//调用
transmit(&num1,&num2);

7.8指针，函数，数组

arr 是一个指向整数数组的指针。指针是一种变量，它存储的是另一个变量的地址。通过指针，我们可以间接地访问和修改变量的值。

数组名本质上是指向数组第一个元素的指针，因此在访问数组元素时不需要解引用。在函数 bort 中，通过指针 arr 可以直接访问和修改变量的值，从而实现冒泡排序算法。

当使用 arr[j] 时，实际上是通过指针间接访问数组的元素。

void bort(int *arr,int length)
{
	for (int i = 0; i < length - 1; i++)
	{
		for (int j = 0; j < length - i - 1; j++)
		{
			if (arr[j] > arr[j + 1])
			{
				int temp = arr[j];
				arr[j] = arr[j +1];
				arr[j +1] = temp;
			}
		}
	}
}
	int arr[10] = {2,2,8,9,66,22,11,0,7};
	int length = sizeof(arr)/ sizeof(arr[0]);
//调用
	bort(arr, length);

八.结构体

8.1概念

用户自定义的数据类型，允许用户存储不同的数据类型

九.类和对象

C++面向对象的三大特征为：封装，继承，多态

C++认为万事万物都皆为对象，对象上有其属性和行为