成员函数重载和非成员函数重载

成员函数重载例子

成员函数重载指的是在类内部定义操作符重载函数，这些函数作为类的成员函数存在。由于成员函数可以隐式地访问类对象的成员，因此它们通常不需要额外的参数来指定操作的对象（除了可能是其他操作数）。

cpp复制代码

	#include <iostream>
	class Complex {
	public:
	double real, imag;
	Complex(double r = 0.0, double i = 0.0) : real(r), imag(i) {}//构造函数
	// 成员函数重载 + 操作符
	Complex operator+(const Complex& rhs) const {
	return Complex(real + rhs.real, imag + rhs.imag);
	}
	// 其他成员函数和方法...
	};
	int main() {
	Complex c1(1.0, 2.0);
	Complex c2(3.0, 4.0);
	Complex c3 = c1 + c2; // 使用成员函数重载的 + 操作符
	std::cout << "c3: (" << c3.real << ", " << c3.imag << ")\n"; // 输出: c3: (4, 6)
	return 0;
	}

在这个例子中，Complex 类重载了 + 操作符，允许两个 Complex 对象相加。operator+ 是一个成员函数，因此它可以隐式地访问调用它的 Complex 对象的 real 和 imag 成员。

非成员函数重载例子

非成员函数重载指的是在类外部定义操作符重载函数，这些函数不是任何类的成员函数。由于它们不是类的成员函数，因此它们不能隐式地访问类对象的成员，而需要通过参数来指定操作的对象。

cpp复制代码

	#include <iostream>
	class Complex {
	public:
	double real, imag;
	Complex(double r = 0.0, double i = 0.0) : real(r), imag(i) {}
	// 其他成员函数和方法...
	// 允许非成员函数访问私有成员的友元声明（可选）
	// 这里不需要，因为我们只使用公共成员
	};
	// 非成员函数重载 + 操作符
	Complex operator+(const Complex& lhs, const Complex& rhs) {
	return Complex(lhs.real + rhs.real, lhs.imag + rhs.imag);
	}
	int main() {
	Complex c1(1.0, 2.0);
	Complex c2(3.0, 4.0);
	Complex c3 = c1 + c2; // 使用非成员函数重载的 + 操作符
	std::cout << "c3: (" << c3.real << ", " << c3.imag << ")\n"; // 输出: c3: (4, 6)
	return 0;
	}

在这个例子中，operator+ 是一个非成员函数，它接受两个 Complex 类型的参数 lhs 和 rhs，分别代表左侧和右侧操作数。由于 operator+ 是非成员函数，因此它需要通过参数来访问 Complex 对象的 real 和 imag 成员。注意，如果 real 和 imag 是私有的，那么我们需要将它们声明为类的友元，以便非成员函数能够访问它们。然而，在这个例子中，我们假设它们是公共的，因此不需要友元声明。

#include <iostream>  
  
class Point {  
public:  
    int x, y;  
  
    // 构造函数  
    Point(int x = 0, int y = 0) : x(x), y(y) {}  
  
    // 重载+操作符，用于两个Point对象的加法  
    Point operator+(const Point& rhs) const {  
        return Point(this->x + rhs.x, this->y + rhs.y);  
    }  
  
    // 重载输出操作符<<，以便可以输出Point对象  
    friend std::ostream& operator<<(std::ostream& os, const Point& p);  
};  
  
// 重载输出操作符<<的定义（需要作为友元函数）  
std::ostream& operator<<(std::ostream& os, const Point& p) {  
    os << "(" << p.x << ", " << p.y << ")";  
    return os;  
}  
  
int main() {  
    Point p1(1, 2);  
    Point p2(3, 4);  
    Point p3 = p1 + p2; // 使用重载的+操作符  
  
    std::cout << "p1: " << p1 << std::endl;  
    std::cout << "p2: " << p2 << std::endl;  
    std::cout << "p1 + p2 = " << p3 << std::endl; // 使用重载的<<操作符  
  
    return 0;  
}

#include <algorithm>
#include <vector>

//普通函数
void print01(int val) 
{
	cout << val << " ";
}
//函数对象
class print02 
{
 public:
	void operator()(int val) 
	{
		cout << val << " ";
	}
};

//for_each算法基本用法
void test01() {

	vector<int> v;
	for (int i = 0; i < 10; i++) 
	{
		v.push_back(i);
	}

	//遍历算法
	for_each(v.begin(), v.end(), print01);
	cout << endl;

	for_each(v.begin(), v.end(), print02());
	cout << endl;
}

int main() {

	test01();

	system("pause");

	return 0;
}

#include <algorithm>
#include <vector>

void myPrint(int val)
{
	cout << val << " ";
}

void test01() {
	vector<int> v;
	v.push_back(10);
	v.push_back(30);
	v.push_back(50);
	v.push_back(20);
	v.push_back(40);

	//sort默认从小到大排序
	sort(v.begin(), v.end());
	for_each(v.begin(), v.end(), myPrint);
	cout << endl;

	//从大到小排序
	sort(v.begin(), v.end(), greater<int>());
	for_each(v.begin(), v.end(), myPrint);
	cout << endl;
}

int main() {

	test01();

	system("pause");

	return 0;
}

在一个类中，如果存在继承关系和子对象的情况 请问其构造和析构函数调用顺序 用c++举出例子 

构造函数的调用顺序
基类构造函数：首先调用基类的构造函数（按照它们在继承列表中的声明顺序）。
成员对象构造函数：然后调用成员对象的构造函数（按照它们在类定义中的声明顺序）。
派生类构造函数：最后调用派生类（子类）的构造函数。
析构函数的调用顺序
析构函数的调用顺序与构造函数相反：

派生类析构函数：首先调用派生类（子类）的析构函数。
成员对象析构函数：然后调用成员对象的析构函数（按照它们在类定义中的声明顺序的反向）。
基类析构函数：最后调用基类的析构函数（按照它们在继承列表中的声明顺序的反向）。
示例代码
cpp
#include <iostream>  
  
// 基类  
class Base {  
public:  
    Base() { std::cout << "Base constructor\n"; }  
    ~Base() { std::cout << "Base destructor\n"; }  
};  
  
// 另一个类，作为成员对象  
class Member {  
public:  
    Member() { std::cout << "Member constructor\n"; }  
    ~Member() { std::cout << "Member destructor\n"; }  
};  
  
// 派生类  
class Derived : public Base {  
private:  
    Member m; // 成员对象  
public:  
    Derived() : m() { std::cout << "Derived constructor\n"; }  
    ~Derived() { std::cout << "Derived destructor\n"; }  
};  
  
int main() {  
    Derived d; // 创建Derived对象  
    return 0;  
}
输出结果
Base constructor // 基类构造函数  
Member constructor // 成员对象构造函数  
Derived constructor // 派生类构造函数  
Derived destructor // 派生类析构函数  
Member destructor // 成员对象析构函数  
Base destructor // 基类析构函数

假设d:\a.txt文件中存储着10个整形数据 数据之间用空格隔开 编写一个程序实现从d：\a.txt文件中读入数据到一个整型数组中然后采用直接选择排序算法对该整型数组进行排序, 把排序后的数组输出到屏幕显示· 用c++

#include <iostream>  
#include <fstream>  
#include <vector>  
#include <sstream>  
  
using namespace std;  
  
// 直接选择排序算法  
void selectionSort(int arr[], int n) {  
    for (int i = 0; i < n - 1; i++) {  
        int minIndex = i;  
        for (int j = i + 1; j < n; j++) {  
            if (arr[j] < arr[minIndex]) {  
                minIndex = j;  
            }  
        }  
        if (minIndex != i) {  
            swap(arr[minIndex], arr[i]);  
        }  
    }  
}  
  
int main() {  
    const int SIZE = 10;  
    int arr[SIZE];  
    ifstream file("d:\\a.txt");  
  
    if (!file.is_open()) {  
        cerr << "无法打开文件d:\\a.txt" << endl;  
        return 1;  
    }  
  
    int i = 0;  
    string line;  
    while (getline(file, line) && i < SIZE) {  
        istringstream iss(line);  
        int num;  
        if (iss >> num) {  
            arr[i++] = num;  
            // 假设每行只有一个整数，并且文件中没有额外的非整数数据  
            // 如果有多个整数或额外的数据，需要添加额外的逻辑来处理  
        }  
    }  
  
    // 如果文件中整数少于10个，则剩余数组元素将保持未初始化状态  
    // 实际应用中可能需要检查并处理这种情况  
  
    // 对数组进行排序  
    selectionSort(arr, i); // 注意：使用实际读取的整数数量i进行排序  
  
    // 输出排序后的数组  
    for (int j = 0; j < i; j++) {  
        cout << arr[j] << " ";  
    }  
    cout << endl;  
  
    file.close();  
    return 0;  
}