【C++编程】数组、函数、结构体、指针、类

原创已于 2024-07-14 16:59:02 修改 · 864 阅读

5 ·

CC 4.0 BY-SA版权

文章标签：

#c++ #开发语言

于 2024-07-12 12:04:30 首次发布

C++ 专栏收录该内容

17 篇文章

订阅专栏

数组：存储一个 固定大小 的 相同类型 元素的顺序集合
- 声明、初始化：type arrayName [size0][size1] ... = {{value00, value01, ...}, {value10, value11, ...}, ...};
```
int my_array[2][3] = {{1,2,3},{4,5,6}};
```
- 访问数组元素：arrayName [index0][index1]...;
```
 int get_element01 = my_array[0][1]; // 获得对应值 2
```

函数：代码模块封装；
- 大型项目中：创建.h头文件，.cpp源文件，在头文件中写函数声明，源文件中写函数定义， #include "xx.h"即可使用.
- 声明: 在函数定义前先告诉编译器函数名称及如何调用：代码按行执行，防止调用时找不到
  - 返回值类型函数名(参数列表类型+名);
  - 可以声明多次 (一般在 .h 头文件)
```
int my_func(int a, int b);
```
- 定义: 函数功能代码编写
  - 返回值类型函数名(参数列表类型+名){函数体语句； return 表达式}
  - 只能定义一次 (一般在 .cpp 源文件)
```
int my_func(int a, int b)   // 没有返回值则可定义为`void`类型
{
	int sum = a + b;
	return sum;
}
```
- 调用: 可以进行值传递或者地址传递
```
// 方法一 - 值传递 (形参改变不会影响实参)：函数名(参数值);
int get_sum = my_func(1, 1); // 获得对应值 2
```
- 重载：同一个作用域下，可以有一组函数名相同，函数参数类型、个数或者顺序不同的函数
```
int my_func(int a, int b)   
{
	int sum = a + b;
	return sum;
}
int my_func(int a, int b, int c)  
{
	int sum = a + b + c;
	return sum;
}

// int get_sum = my_func(1, 1);
// int get_sum = my_func(1, 1, 1);
// 上述均可正常执行函数调用
```
  - 参考链接 - 史上最详细的C++函数重载机制

结构体：自定义数据类型

创建：struct 结构体名 {结构体成员列表}
```
struct my_struct
{
	int a;
	float b;
}
```

实例：结构体名变量名， 变量名.成员名=成员值

// 结构体指针使用 `->` (而非 `.`) 访问结构体变量
struct my_struct s;
s.a = 1;
s.b = 1.1;

指针：指针其实就是一个地址
- 一般指针： 类型 * 变量名 = NULL
```
int a = 10;
int * p =  NULL;
p = &a; 	 		 // `&`取地址，获取 a 对应地址
int value_a = *p; // `*`取值, 获取对应值 10
```
- 特殊的，const 修饰的指针：常量指针、指针常量 …
  - 常量指针 - const 修饰指针(const int * p)：指针指向的值(*p=)不可以改
  - 指针常量 - const 修饰常量(int * const p)：指针的指向(p=)不可以修改
  - const 修饰指针和常量(const int * const p) ：都不可以修改

类：封装、继承、多态

结构体和类的区别：struct的默认权限是public, class的默认权限是private.

定义：编写类名、成员属性和函数

class 类名
{
	public:  //(成员在类内外可以访问) 或者protected(仅类内，可被继承)、private(仅类内，不可被继承)
		// 成员属性
		int AAA;
		int BBB;
		int CCC;
		
		//成员函数：一般功能函数、以及构造、析构函数
		
	    // -- 构造函数,创建对象的时候，构造函数自动调用
		// 如果自己不写，有默认的 构造函数 和 拷贝构造函数(值拷贝，注意是浅拷贝-共享内存)
		// 写法一：
		类名(int a, int b, int c)  // 可以有参数可重载
		{
			// 构造函数主体	
			AAA = a; 
			BBB = b;
			CCC = c;
			// 没有返回值
		}
		// 写法二：利用初始化列表，效果同写法一
		类名(int a, int b, int c): AAA(a), BBB(b), CCC(c)
		{
		}
		
		// -- 析构函数：销毁对象的时候，析构函数自动调用
		~类名() // 不可以有参数，不可重载
		{
			// 析构函数主体
		}
}

特殊成员: 静态成员 & 常函数 -> 详细博客参考链接
友元 : friend - 让一个函数或者类访问另一个类中的私有成员 -> 详细博客参考链接

生成对象： 类名对象名(构造函数参数)；

继承：class 新类的名字:继承方式继承类的名字{}; -> 详细博客参考链接

继承方式	public	protected	private
基类 public 成员	➡ public 成员	➡ protected 成员	➡ private 成员
基类 protected 成员	➡ protected 成员	➡ protected 成员	➡ private 成员
基类 private成员	❌不可见	❌不可见	❌不可见

多态: 利用函数重载的静态多态 & 利用 virtual 虚函数的动态多态 - 详细博客参考链接
纯虚函数和抽象类：virtual 返回值类型函数名(参数表)= 0; - 详细博客参考链接