C++面向对象综述和两个排序方法

C++学习笔记2022.4.16

一、课上学习部分

至今为止学习了面向对象的基本概念

面向对象基础

对象：数据+操作（属性+函数）
类：具有相同数据和操作的一组对象的抽象集合
总是先声明类，再创造对象
消息：一个对象向另一个对象发出一个的请求
消息三个性质：
1.一个对象可接受多种消息
2.相同消息可传递多个对象
3.消息不一定有响应
调用对象的函数就是向该对象传递一个消息
对象所能实现的操作称为方法
方法的一系列操作是由成员函数实现的
个人感觉：面对过程倾向于对算法进行更新，面向对象编程倾向于工程实践

面向对象的基本特征

封装：隐蔽一定信息，提供函数接口
继承：父类与子类的关系称为继承
继承有三个特性：
1、共享特性
2、差别和新增部分
3、类间具有层次结构
继承的作用——实现类的复用
1、避免公用代码重复开发，减少代码
2、减少接口
多态：不同对象对相同消息的方法不同
多态的分类：
1、编译多态（提前绑定）
函数重载和运算符重载
2、运行多态（动态绑定）
虚函数

面向对象程序设计的语言

1、Smalltalk语言
2、C++
3、Java——静态面向对象编程语言的代表
4、python——完全支持继承、重载、派生和多态
5、C#

IDE

1、dev-C++
2、vs,vs code
3、code blocks;eclipse等

二、算法学习部分

以下是从小到大的冒泡排序

void arraycomp(int arr[],int n) {
	//传递数组地址和数组个数，数组个数可以用sizeof(arr)/sizeof(int)求出
	for(int t=0; t<n-1; t++) {
		for(int j=0; j<n-t-1; j++) {
			if(arr[j]>arr[j+1])
				swap(arr[j],arr[j+1]);
		}
	}
}

C++可以使用重载，那么就意味着如果我将函数传递参数改为

void arraycomp(double arr[],int n) 

此时就可以实现对于浮点数类型的数组的冒泡排序的运算。本着学以致用的原则，我们可以通过加入默认值如下，这样我们就能实现通过flag控制大小顺序。

void arraycomp(int arr[],int n,int flag=1) {
	//flag等于1则从小到大，否则从大到小 
	//传递数组地址和元素个数，个数可以用sizeof(arr)/sizeof(int)求出
	cout << n <<endl;
	for(int t=0; t<n-1; t++) {
		for(int j=0; j<n-t-1; j++) {
		if(flag==1)
			{if(arr[j]>arr[j+1])
				swap(arr[j],arr[j+1]);}
		else
			{if(arr[j]<arr[j+1])
				swap(arr[j],arr[j+1]);}
		}
	}
}

值得注意的是，如果出现下面的情况，重载和默认值会冲突，产生错误。

void arraycomp(int arr[],int n);
void arraycomp(int arr[],int n,int flag=1);

此时调用如下

int main() {
	int arr[] = {4,2,8,0,5,4,1,3,9};
	//总排序代码
	int n=sizeof(arr)/sizeof(int);
	cout << n <<endl;
	arraycomp(arr,sizeof(arr)/sizeof(int));
	for (int i=0; i<9; i++) {
		cout << arr[i] << " ";
	}
	return 0;
}

报错为：[Error] call of overloaded ‘arraycomp’ is ambiguous
C++中函数的嵌套与C类似，下面写了一段快速排序的代码，理论上快速排序是目前基于比较的内部排序中最好的方法，特别是当待排序的序列是随机分布时，快速排序的平均时间最短。

void arraycomp(int arr[],int n,int flag=1) {
	//flag默认等于1则从小到大，否则从大到小
	Quicksort(arr,0,n-1);
	if(flag!=1)
	 for (int i = 0; i < n/2; ++i) {
        swap(arr[i],arr[n-1-i]);
    }
}
void Quicksort(int arr[],int L,int R) {
	if(L>R)
	return;
	int left=L,right=R;
	int trig = arr[left];
	while(left<right) {

		while(left<right&&arr[right]>=trig) {
			right--;
		}
		if(left<right)
			arr[left]=arr[right];
		while(left<right&&arr[left]<=trig) {
			left++;
		}
		if(left<right)
			arr[right]=arr[left];
		if(left>=right) {
			arr[left]=trig;
		}
	}
	Quicksort(arr,L,left-1);
	Quicksort(arr,right+1,R);
}

今天到这里啦，周日早上能睡12 h真舒服。