c++自学

吃辣椒不加蒜

已于 2024-08-14 10:48:24 修改

阅读量1k

点赞数 28

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

于 2024-08-13 10:16:44 首次发布

本文链接：https://blog.csdn.net/maomaoaibai/article/details/140498268

版权

BV1et411b73Z

一.基础知识

01.1hello world

c++基本框架

“Hello world”代码

01.2编译

编译器会将代码编译成为机器语言

编译器所作的生成.obj文件
在c++中没有所谓的文件，文件只是提供给编译器代码的一种方式。

01.3基础知识

注释：

变量：

标识符起名规则：

01.4数据类型

c++规定在创建一个变量或者常量的时候，必须要指定相应的数据类型，否则无法给变量分配内存

1.整型：

整型变量描述的是整数类型的数据

2.sizeof关键字

sizeof关键字可以用来统计数据类型所占的大小

使用sizeof计算变量字节大小：

3.实型/浮点型

用来表示小数

4.字符型

字符型变量用来表示单个字符

char a=‘a’;

5.转义字符

用来表示一些不能显示出来的ASCII字符

6.字符串型

来用表示一串字符

字符串实际上是使用 null 字符 \0 终止的一维字符数组。因此，一个以 null 结尾的字符串，包含了组成字符串的字符。

注意：c++风格的字符串要有#include<string>头文件

7.布尔类型

bool类型表示真或假的值

8.数据的输入

从键盘获取数据

用于执行代码的运算

01.5运算符

1.算术运算符

2.赋值运算符

3.比较运算符

4.逻辑运算符

二.程序流程结构

支持三种最基本的程序流程结构：顺序结构，选择结构，循环结构

02.1选择结构

1.if语句

#include<iostream>//预处理,在实际发生编译前就完成处理。include的目的是找到文件
using namespace std;
int main()
{
	int a=0;
	cin >> a;
	if (a > 0)
	{
		cout << "a的值为：" << a << endl;
	}
	else
	{
		cout << "a的值小于0" << endl;
	}
	cin.get();
}

2.switch语句

#include<iostream>//预处理,在实际发生编译前就完成处理。include的目的是找到文件
using namespace std;
int main()
{
	int a=0;
	cout << "请输入a的值：" << endl;
	cin >> a;
	switch (a)
	{	
		case 0:
		{
			cout << a << endl;
		
		}
		case 1:
		{
			cout << a+1 << endl;
		}
		case 2:
		{
			cout << a+2 << endl;
		}

	}
	cin.get();
}

switch嵌套实例

#include <iostream>
using namespace std;
 
int main ()
{
   // 局部变量声明
   int a = 100;
   int b = 200;
 
   switch(a) {
      case 100:
         cout << "这是外部 switch 的一部分" << endl;
         switch(b) {
            case 200:
               cout << "这是内部 switch 的一部分" << endl;
         }
   }
   cout << "a 的准确值是 " << a << endl;
   cout << "b 的准确值是 " << b << endl;
 
   return 0;
}

02.2 循环结构

1.while循环

2.do while 循环

请注意，条件表达式出现在循环的尾部，所以循环中的 statement(s) 会在条件被测试之前至少执行一次。

如果条件为真，控制流会跳转回上面的 do，然后重新执行循环中的 statement(s)。这个过程会不断重复，直到给定条件变为假为止。

3.for循环

4.goto语句

三,数组

所谓的数组就是一个集合，里面放了相同类型的数据元素

03.1一维数组

#include <iostream>
using namespace std;
 
#include <iomanip>
using std::setw;
 
int main ()
{
   int n[ 10 ]; // n 是一个包含 10 个整数的数组
 
   // 初始化数组元素          
   for ( int i = 0; i < 10; i++ )
   {
      n[ i ] = i + 100; // 设置元素 i 为 i + 100
   }
   cout << "Element" << setw( 13 ) << "Value" << endl;
 
   // 输出数组中每个元素的值                     
   for ( int j = 0; j < 10; j++ )
   {
      cout << setw( 7 )<< j << setw( 13 ) << n[ j ] << endl;
   }
 
   return 0;
}

一维数组案例：冒泡排序

#include <iostream>
using namespace std;

#include <iomanip>
using std::setw;

int main()
{
	int arr[9] = { 2,5,11,66,32,7,4,82,32 };
	int b = 0;
	cout << "排序前的结果：" << endl;
	for (int a = 0; a < 9; a++)
	{
		cout << arr[a] << " ";
	}
	cout << endl;
	for (int i =0; i<9-1; i++)
	{
		for (int j =0; j<9-i-1; j++)
		{
			if (arr[j] >arr[j+1])
			{
				b = arr[j+1];
				arr[j +1] = arr[j];
				arr[j] = b;
			}
		}

	}
	cout << "排序后的结果：" << endl;
	for (int c = 0; c < 9; c++)
	{
		cout << arr[c] << " ";
	}
	cout << endl;
	return 0;
}

03.2二维数组

在一维数组的基础上增加一个维度

我们可以利用二维数组名查看二维数组所占内存空间，可以获取二维数组的首地址

四，函数

将一段经常使用的代码进行封装，减少重复代码

04.1函数定义和调用

创建 C++ 函数时，会定义函数做什么，然后通过调用函数来完成已定义的任务。

当程序调用函数时，程序控制权会转移给被调用的函数。被调用的函数执行已定义的任务，当函数的返回语句被执行时，或到达函数的结束括号时，会把程序控制权交还给主程序。

调用函数时，传递所需参数，如果函数返回一个值，则可以存储返回值。

在代码中i,j为形式参数，a,b为实际参数

04.2函数值传递和申明

所谓值传递，就是函数调用时实参将数值传递给形参

值传递时，若形参发生改变不会影响实参

#include <iostream>
using namespace std;
 
// 函数声明
void swap(int x, int y);
 
int main ()
{
   // 局部变量声明
   int a = 100;
   int b = 200;
 
   cout << "交换前，a 的值：" << a << endl;
   cout << "交换前，b 的值：" << b << endl;
 
   // 调用函数来交换值
   swap(a, b);
 
   cout << "交换后，a 的值：" << a << endl;
   cout << "交换后，b 的值：" << b << endl;
 
   return 0;
}
// 函数定义
void swap(int x, int y)
{
   int temp;
 
   temp = x; /* 保存 x 的值 */
   x = y;    /* 把 y 赋值给 x */
   y = temp; /* 把 x 赋值给 y */
  
   return;
}

函数申明的作用：

告诉编译器函数名称和如何调用函数，函数的实际主体可以单独定义。

函数的申明可以多次，但是函数的定义只能有一次。

04.3函数的分文件编写

main.cpp

c++.h

五，指针

05.1指针的定义和使用

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

内存编号都是从0开始记录，一般用十六进制表示

可以利用指针变量保存地址

05.2指针所占内存空间

在32位操作系统下，内存大小为4个字节

在64位操作系统下，内存大小为8个字节

05.3空指针与野指针

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

用途：初始化指针变量

注意：空指针指向的内存方向是不可以访问的

不能运行，报错

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

05.4const修饰指针

const修饰指针的三种情况：

1.const修饰指针-----常量指针

2.const修饰常量-----指针常量

3.const既修饰指针，又修饰常量

05.5指针和数组

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

05.6指针和函数

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

#include <iostream>
using namespace std;
void swap(int* p1, int* p2)
{
	int temp = 0;
	temp = *p1;
	*p1 = *p2;
	*p2 = temp;
	cout << "p1 "<< * p1 << endl;
	cout << "p2 "<< * p2 << endl;
}
void swap2(int i, int j)
{
	int temp = 0;
	temp = i;
	i = j;
	j= temp;
	cout << "i " <<i<< endl;
	cout << "j " <<j<< endl;
}
void main()
{
	int a = 10;
	int b = 20;
	int c = 10;
	int d = 20;
	swap(&a, &b);
	cout << a << endl;
	cout << b << endl;
	swap2(c, d);
	cout << c<< endl;
	cout << d<< endl;
}

地址传递会改变参数

05.7案例

案例：封装一个函数，利用冒泡排序，实现对整型数组的升序排列

#include <iostream>
using namespace std;
void momo(int* p, int len)
{
	for (int i = 0; i < len; i++)
	{
		for (int j = 0; j < len - i - 1; j++)
		{
			if (p[j] > p[j + 1])
			{
				int temp = 0;
				temp = p[j];
				p[j] = p[j + 1];
				p[j + 1] = temp;
			}
		}
	}
}

void main()
{
	int arr[10] = { 4,3,6,9,1,2,10,8,7,5 };
	int len = sizeof(arr) / sizeof(arr[0]);
	momo(arr,len);
	for (int i = 0; i < len; i++)
	{
		cout << arr[i] << endl;
	}
}

六，结构体

06.1结构体的定义和使用

结构体属于用户自定义的数据类型，允许用户存储不同的数据类型

c++.h

#pragma once
#include <iostream>
#include<string>
using namespace std;
struct student
{
	int age;
	string name;
	string ID;


}s3;//第三种在结构体后面顺便创建变量然后再后面赋值

main.cpp

#include"c++.h"
int main()
{
	//第一种赋值
	struct student s1;
	s1.age = 10;
	s1.name = "zhangsan";
	s1.ID = "2205100236";
	cout << "张三的年龄：" << s1.age <<" ID："<<s1.ID << endl;
	//第二钟赋值
	struct student s2={20,"李四","2205100237"};
	cout << "李四的年龄：" << s2.age << " ID：" << s2.ID << endl;

	return 0;
}

06.2结构体数组

将自定义的结构体放入数组中方便维护

#include <iostream>
#include<string>
using namespace std;
//创建结构体
struct student
{
	string name;
	int age;
	string ID;
};
int main()
{
	//创建结构体数组且给结构体元素赋值
	struct student arr[2] =
	{
		{"张三",3,"2205"},
		{"李四",5,"2205"}

	};
	//修改元素赋值
	arr[1].age = 1;
	//遍历结构体数组
	for (int i = 0; i < 2; i++)
	{
		cout << arr[i].name << arr[i].age << arr[i].ID << endl;
	}
	return 0;
}

06.3结构体指针

通过指针访问结构体中的成员

利用操作符“->”可以通过结构体指针访问结构体属性

#include <iostream>
#include<string>
using namespace std;
//创建结构体
struct student
{
	string name;
	int age;
	string ID;
};
int main()
{
	//1.创建结构体变量
	student s1 = { "张三",4,"2205" };
	//2.通过指针指向结构体变量
	struct student * p = &s1;
	//通过指针变量访问结构体变量
	p->age = 22;
	cout << p->name << p->age <<" " << p->ID << endl;

	return 0; 
}

06.4结构体嵌套结构体

结构体中的成员可以是另一个结构体

#include <iostream>
#include<string>
using namespace std;
//创建结构体
struct student
{
	string name;
	int age;
	string ID;
};
struct techer
{
	string name;
	int age;
	struct student stu;
};

int main()
{
	techer t;
	t.age = 29;
	t.name = "张三";
	t.stu.age = 10;
	t.stu.ID = "2205";
	t.stu.name = "李四";


	return 0; 
}

06.5结构体做函数参数

将结构体作为函数参数向函数中传递

传递方式有两种：值传递地址传递

#include <iostream>
#include<string>
using namespace std;
//创建结构体
struct student
{
	string name;
	int age;
	string ID;
};
//值传递
void printstu1(student s)
{
	s.age = 100;
	cout << "值传递中子函数中打印结果：" << s.age << " " << s.ID << s.name <<endl;
}
//地址传递
void printstu2(student *p)
{
	p->age = 100;
	cout << "地址传递中子函数中打印结果：" << p->age << " " << p->ID << p->name<<endl;
}
int main()
{
	student stu;
	stu.age = 10;
	stu.ID = "2205";
	stu.name = "张三";
	cout << "main函数中打印结果：" << stu.age << " " << stu.ID << stu.name<<endl;
	printstu1(stu);
	cout << "main函数中打印结果：" << stu.age << " " << stu.ID << stu.name << endl;
	printstu2(&stu);
	cout << "main函数中打印结果：" << stu.age << " " << stu.ID << stu.name << endl;
	return 0; 
}

06.6结构体中const使用情况

用const防止误操作

#include <iostream>
#include<string>
using namespace std;
//创建结构体
struct student
{
	string name;
	int age;
	string ID;
};
//加上const如果在函数中修改变量则会报错
void printstu1(const student *s)
{
	cout << "打印结果：" << s->age << " " << s->ID << s->name <<endl;
}

int main()
{
	student stu;
	stu.age = 10;
	stu.ID = "2205";
	stu.name = "张三";
	printstu1(&stu);
	
	return 0; 
}