C++ 基础进阶

C++ 基础进阶

内容概述：

• 函数重载：int add(int x, inty);，long long add(long long x, long long y);，double add(double x, double y);
• 模板函数：template<typename T> 或 template<class T>
• 结构体：
  1. 构造函数：与结构体名称保持一致的函数，注意：构造函数没有返回值。
  2. 结构体函数：结构体中的普通函数，可以通过 . 进行调用。
  3. 运算符重载：operator 运算符。
• const 在函数中的作用：const 可以修饰整个函数，可以只修饰函数的参数，可以只修饰函数体。
• 扩展：字符串与数字之间的转换。

一、 函数重载

可以用一个函数名构造多个函数，各个同名函数之间参数一定不同。要满足以下规则任意一条：

1. 函数的参数类型不同。
2. 函数的个数不同。
3. 函数的参数不同。

注意:仅有函数的返回值不同不能进行函数重载!

int add(int x, int y){return x + y;
}long long add(long long x, long long y){return x + y;
}double add(double x, double y){return x + y;
}

二、模板函数

声明模板参数的方式：template<typename T> 或 template<class T>，其中 T 是人为设定的，可以用任何标识符表示。

模板参数的意义：可以使用模板参数来表示任意的数据类型的参数。

使用模板参数可以定义模板函数，即将参数的类型都设置为 T 或 将返回值类型设置为 T。

模板函数

// 定义模板函数
template<typename T>
T add(T x, T y){return x + y;
}// 调用模板函数
add(1, 2);				// 隐式调用，可以自动推算出变量类型add<double>(1.14, 2.37);		// 显示调用，指定参数类型为 double

三、结构体

1. 构造函数

在结构体中直接定义一个与结构体同名的函数，要求这个函数没有返回值。

构造函数一旦结构体被实例化就直接被调用。

// 定义
struct Node{char name[10];int length;// 不带参数的构造函数Node(){this->length = 0;    // 直接将实例化的结构体中 len 初始化为0；也可以直接使用：len = 0;this->name[0] = '\0';    // 修正：应该将第一个字符设为结束符cout<<"空空如也"<<endl;}// 带参数的构造函数Node(const char* name_t, int len){		// 因为传入的是一个字符串常量，但是这里的参数是一个指针，是不安全的，因此要加const进行修饰int i = 0;while(i < len && len < 9){name[i] = name_t[i];i++;}length = len;  // 修正：删除了多余的字符name[length] = '\0';cout<<"我的名字是："<<name<<endl;}
};// 调用方式一（推荐）：
Node n;				// 输出 “空空如也”
Node m("kongkong", 8);	// 输出 “我的名字是：kongkong”，注意如果是输入“空空”的话会出现问题，中文UTF-8实际上会占用多个字节。// 调用方式二：
Node n = Node();				// 输出 “空空如也”
Node m = Node("kongkong", 8)	// 输出 “我的名字是：kongkong”

2. 结构体函数

向定义普通函数一样在结构体中定义函数

结构体函数与普通函数的区别：

1. 结构体函数能够直接访问结构体实例中的变量。
2. 结构体函数只能供结构体实例调用，调用方式为：实例.结构体函数(参数1, 参数2, ...)

// 定义
struct Node{string fruit;void print(){printf("我是 %s 水果", fruit.c_str());}
};int main(){Node f;f.fruit = "apple";f.print();return 0;
}

3. 运算符重载

运算符重载通常用在结构体中，用于处理相同类型的结构体之间的运算关系

方法：operator 运算符

struct Node{string fruit;Node(string a){fruit = a;}// 重载运算符为string operator+ (const Node &other){return this->fruit + other.fruit;}
};int main(){Node f("apple");Node l("banana");cout<<(f + l)<<endl;	// 输出applebananareturn 0;
}

const 在函数中的作用

1. const 修饰整个函数：表示返回值是一个常量，这样使用几乎无意义。

   const int add(int x, int y){return x + y;
   }
   

2. const 修饰函数的参数：表示参数是要给常量，值不可修改。

   int add(const int x, int y){...}	// x 不可以在函数进行修改
   int add(const int* ptr, int y){...}	// ptr 指针所指向的值是一个常量，不可修改
   int add(int* const ptr, int y){...}	// prt 指针本身不能被修改。
   

3. conste 修饰函数体：常用在结构体中，修饰函数体会将结构体中的所有变量都修改为 const 类型的，相当于ptr* 转变为了 const ptr *。

   struct Node{string name;bool change(string new_name) const {this->name = new_name;		// 这是错误的，结构体中的name已经变成了常量类型的。}
   };
   

四、综合代码：

// 结构体的各种操作
#include<iostream>
#include<stdlib.h>
using namespace std;
/*目标：给出一个整数序列，要求：1. 自动求出这个序列的奇数的个数与偶数的个数, 如果没有给出序列则直接进行简单的初始化。 2. 选择性的求出奇数数字或偶数数字的总和， 3. 重载加号运算符，要求两个结构体相加即为长度相加，并进行返回。4. 设置一个函数，要求根据输入（可能是整数类型或浮点数类型的数据）与长度进行相加，表示该数的特征值，并且返回该值。 
*/const int MAXSIZE = 1000;
struct Nums{int nums[MAXSIZE];int length;						// 序列长度 int odd_number, even_number;	// 奇数个数，偶数个数 // 自动求出奇数个数与偶数个数(构造函数不能有返回值！！！)Nums(){this->odd_number = 0;this->even_number = 0;	// 赋初值为 0;length = 0;				// 不使用this也表示结构体中的变量。return ;}Nums(int *o_nums, int o_len){this->odd_number = 0;this->even_number = 0;	// 赋初值为 0;length = o_len;for(int i = 0;i < o_len;i ++){if(o_nums[i] % 2 == 0){this->even_number ++;}else this->odd_number++;nums[i] = o_nums[i];}}// 计算奇数元素的总和 int to_sum_odd() const {int i = 0, odd_sum = 0;while(i < length){if(nums[i] % 2 != 0) odd_sum += nums[i];++ i;}return odd_sum;} // 计算偶数元素的总和 int to_sum_even() const {int i = 0, even_sum = 0;while(i < length){if(nums[i] % 2 == 0) even_sum += nums[i];++ i;}return even_sum;}template<typename T>T to_add_feature(const T other) const {return other + length;}// 重载运算符int operator+(const Nums& other) const {return this->length + other.length;} // 遍历输出这个序列 void traverse(){for(int i = 0;i < length;i ++){cout<<nums[i]<<' ';}cout<<endl;}
};
int main(){// 这里使用开辟内存的方式来表示数组，当然可以使用 temp[maxsize] 来表示数组 
//	int *temp = new int[12]{1, 2 ,3 ,4 ,5, 6, 7, 8, 9, 10, 11, 12};// 遍历赋值 
//	int *temp = new int[12];
//	for(int i = 0;i < 12;i ++) temp[i] = i * (i + 1) + 1;// 也可以使用malloc开辟空间 int* temp = (int*)malloc(sizeof(int) * 5);for(int i = 0;i < 12;i ++) temp[i] = i * (i + 1) + 1;Nums n(temp, 12);	// 也可以使用 Nums n = Nums(temp, 125); 推荐使用Nums n = (temp, 12); 来初始化结构体。 // 得到奇数之和 cout<<"奇数之和："<<n.to_sum_odd()<<endl; // 得到偶数之和cout<<"偶数之和："<<n.to_sum_even()<<endl;// 分别计算得到5 与 3.14的特征值cout<<"5 的特征值为："<<n.to_add_feature(5)<<endl;cout<<"3.14 的特征值为："<<n.to_add_feature(3.14)<<endl;// 定义第二个结构体int* t_arr = new int [5]{1, 2, 3, 4, 5};Nums m(t_arr, 5);cout<<"m + n = "<<m + n<<endl;// 遍历输出序列 cout<<"遍历输出序列: "<<endl;n.traverse();m.traverse();// 释放空间 
//	delete temp;delete t_arr;free(temp);return 0;
} 

扩展1：字符串与数字之间的转换

1. 任意数字类型转换为字符串：to_string()；

   int a = 10;
   double b = 3.14;string a_s = to_string(a);
   string b_s = to_string(b);
   

2. 字符串转换为数字类型：

   string s1 = "30";
   string s2 = "3.14";// 转换为 int类型
   int s_i = stoi(s1);// 转换为 long long类型
   int s_l = stoi(s1);// 转换为 float 类型
   int s_f = stoi(s2);// 转换为 double 类型
   int s_d = stoi(s2);
   

3. 提取字符串中的字符转换为整型：

   string s = "1+2";// 方式一：
   int a1 = s[0] - '0';
   int a2 = s[2] - '0';// 方式二：substr 用于提取字串，substr(起始位置，提取长度)
   int b1 = stoi(s.substr(0, 1));
   int b2 = stoi(s.substr(2, 1));
   

扩展2：开辟空间的方法

1. 使用malloc() 和 free() 函数，注意要导入头文件<stdlib.h>

   int* i_ptr = (int*)malloc(sizeof(int) * 10);	// 要进行强制类型转换
   free(i_ptr);									// 一定要释放开辟的内存空间
   

2. 使用new 和 delete 方法

   int* i_ptr = new int;		// 也可以加括号， new(int);
   delete i_ptr;				// 也可以添加括号, delete(i_ptr);// 指向一篇连续空间
   int* j_ptr = new int[10]{1, 2 ,3 ,4, 5};		// 直接进行初始化
   delete[] j_ptr;									// 删除连续空间需要加[]char* k_ptr = new char[8]{};
   delete[] k_ptr;