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> - 结构体：
- 构造函数：与结构体名称保持一致的函数，注意：构造函数没有返回值。
- 结构体函数：结构体中的普通函数，可以通过
.进行调用。 - 运算符重载：
operator 运算符。
- const 在函数中的作用：
const可以修饰整个函数，可以只修饰函数的参数，可以只修饰函数体。 - 扩展：字符串与数字之间的转换。
一、 函数重载
可以用一个函数名构造多个函数，各个同名函数之间参数一定不同。要满足以下规则任意一条：
- 函数的参数类型不同。
- 函数的个数不同。
- 函数的参数不同。
注意:仅有函数的返回值不同不能进行函数重载!
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, ...)
// 定义
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; // 输出applebanana
return 0;
}
const 在函数中的作用
-
const修饰整个函数：表示返回值是一个常量，这样使用几乎无意义。const int add(int x, int y){ return x + y; } -
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 指针本身不能被修改。 -
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：字符串与数字之间的转换
-
任意数字类型转换为字符串：
to_string()；int a = 10; double b = 3.14; string a_s = to_string(a); string b_s = to_string(b); -
字符串转换为数字类型：
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); -
提取字符串中的字符转换为整型：
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：开辟空间的方法
-
使用
malloc()和free()函数，注意要导入头文件<stdlib.h>int* i_ptr = (int*)malloc(sizeof(int) * 10); // 要进行强制类型转换 free(i_ptr); // 一定要释放开辟的内存空间 -
使用
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;
