C++计算器实现 ——（完整功能实现、设计分析）

已于 2023-09-20 12:02:55 修改
阅读量4.8w 收藏 646
点赞数 133
分类专栏： C++程序实现 文章标签： c++
于 2021-01-07 22:58:47 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/demo_yo/article/details/112340758
版权
该博客介绍了使用C++实现一个支持多种运算符和数据类型的计算器，包括加减乘除、幂次方、绝对值和阶乘。计算器采用后缀表达式法进行运算，通过符号栈和数字栈处理运算符优先级，同时处理括号和绝对值符号的奇偶性。此外，还提供了表达式的自定义标准格式化功能。
摘要由CSDN通过智能技术生成

基于标准C++的计算器实现。

一、需求实现

1、实现功能：

支持运算符：+, - , *, /, %（百分号）, ^（幂次方）, | |（绝对值），！（阶乘）。其他符号：( ) [ ] { }

支持数据类型：正负数、小数。

2、实现方法

符号优先级处理方法：符号等级制

运算表达式处理方法：后缀表达式法

后缀表达式转换及计算辅助方法：符号栈、数字栈

二、设计实现

总体设计：

计算器类

//计算器类
class Calculator
{
public:
	Calculator();
	void getFormat();					//表达式自定义标准格式化
	int getPrior(char c);				//获取算术符号优先级
	void getPostfix();					//后缀表达式转换
	void calResult();					//计算结果
	void calculate();					//计算方法
	double getResult();					//获取结果

	string operatorSym;					//运算符号
	string infix;						//表达式缓存

private:
	vector<string> postfix;				//后缀表达式向量
	stack<char> symStack;				//符号栈
	stack<double> figStack;				//数字栈
	string stdInfix;					//自定义标准格式化表达式
	double result;						//最终计算结果
};
1、运算优先级功能实现
（1）运算符等级

声明为枚举常量（在整个类中恒定），便于数据管理、数据与程序分离。

//算术符号优先权等级
enum PRIO_LV {
	PRIO_LV0 = 0,
	PRIO_LV1 = 1,
	PRIO_LV2 = 2,
	PRIO_LV3 = 3,
	PRIO_LV4 = 4,
};
（2）运算符优先级获取

用于运算优先级比较的依据。

//获取算术符号优先级
int Calculator::getPrior(char c) {

	if (c == '+' || c == '-') {
		return PRIO_LV1;
	}
	else if (c == '*' || c == '/') {
		return PRIO_LV2;
	}
	else if (c == '%' || c == '^') {
		return PRIO_LV3;
	}
	else if (c == '！') {
		return PRIO_LV4;
	}
	else {
		return PRIO_LV0;
	}
	//else { cout << c << 非法符号！ << endl; }
}
2、绝对值符号奇偶性实现
//绝对值符号个数的奇偶性
enum ABS_ODEVITY {
	ABS_ODD = 1,
	ABS_EVEN = 2,
};
3、正负数运算实现

//表达式自定义标准格式化
void Calculator::getFormat() {

	stdInfix = infix;

	//实现正负数
	//for (int i = 0; i < stdInfix.length(); i++) {			//string下标调用运算符时可能会导致类型溢出
	for (size_t i = 0; i < stdInfix.size(); i++) {			//string.size()返回size_type类型，避免下标运算时的类型溢出
		if (stdInfix[i] == '-' || stdInfix[i] == '+') {		//-x转换为0-x，+x转化为0+x
			if (i == 0) {
				stdInfix.insert(0, 1, '0');
			}
			else if (stdInfix[i - 1] == '(') {
				stdInfix.insert(i, 1, '0');
			}
		}
	}
}
4、后缀表达式转换

要直接对表达式求值，首先要能够正确解释表达式，或者翻译成能正确求值的一个机器指令序列，以便计算机的处理执行。因此有前缀表达式和后缀表达式方法，此处采用较为广泛的后缀表达式方法。

//后缀表达式转换
void Calculator::getPostfix() {

	int absNumeber = ABS_ODD;				//绝对值符号个数的奇偶性
	string tmp;

	//for (int i = 0; i < stdInfix.length(); i++) {
	for (size_t i = 0; i < stdInfix.size(); i++) {					//string.size()返回size_type类型，避免下标运算时的类型溢出
		tmp = "";
		switch (stdInfix[i]) {
		case '+':
		case '-':
		case '*':
		case '/':
		case '%':
		case '^':
		case '!':
			if (symStack.empty() || symStack.top() == '(' || symStack.top() == '[' || symStack.top() == '{' || (symStack.top() == '|' && absNumeber == ABS_ODD)) {
				symStack.push(stdInfix[i]);
			}
			else {
				while (!symStack.empty() && (getPrior(symStack.top()) >= getPrior(stdInfix[i]))) {
					tmp += symStack.top();
					postfix.push_back(tmp);
					symStack.pop();
					tmp = "";
				}
				symStack.push(stdInfix[i]);
			}
			break;
		case '|':
			if (absNumeber == ABS_ODD) {
				symStack.push(stdInfix[i]);
				absNumeber = ABS_EVEN;
			}
			else{
				while (!symStack.empty() && symStack.top() != '|') {
					tmp += symStack.top();
					postfix.push_back(tmp);
					symStack.pop();
					tmp = "";
				}
				if (!symStack.empty() && symStack.top() == '|') {
					tmp += symStack.top();
					postfix.push_back(tmp);						//左绝对值符号'|'加入后缀表达式，用于绝对值的检测计算
					symStack.pop();
					absNumeber = ABS_ODD;
				}
			}
			break;
		case '(':
		case '[':
		case '{':
			symStack.push(stdInfix[i]);
			break;
		case ')':
			while (!symStack.empty() && symStack.top() != '(') {
				tmp += symStack.top();
				postfix.push_back(tmp);
				symStack.pop();
				tmp = "";
			}
			if (!symStack.empty() && symStack.top() == '(') {
				symStack.pop();							//将左括号出栈丢弃
			}
			break;
		case ']':
			while (!symStack.empty() && symStack.top() != '[') {
				tmp += symStack.top();
				postfix.push_back(tmp);
				symStack.pop();
				tmp = "";
			}
			if (!symStack.empty() && symStack.top() == '[') {
				symStack.pop();							//将左括号出栈丢弃
			}
			break;
		case '}':
			while (!symStack.empty() && symStack.top() != '{') {
				tmp += symStack.top();
				postfix.push_back(tmp);
				symStack.pop();
				tmp = "";
			}
			if (!symStack.empty() && symStack.top() == '{') {
				symStack.pop();							//将左括号出栈丢弃
			}
			break;
		default:
			if ((stdInfix[i] >= '0' && stdInfix[i] <= '9')) {
				tmp += stdInfix[i];
				while (i + 1 < stdInfix.length() && (stdInfix[i + 1] >= '0' && stdInfix[i + 1] <= '9' || stdInfix[i + 1] == '.')) {		//小数处理

					tmp += stdInfix[i + 1];			//是连续的数字，则追加
					i++;
				}
				if (tmp[tmp.length() - 1] == '.') {
					tmp += '0';						//将x.做x.0处理
				}
				postfix.push_back(tmp);
			}
			break;
		}//end switch
	}//end for

	//if(!symStack.empty()) {
	while (!symStack.empty()) {						//将栈中剩余符号加入后缀表达式
		tmp = "";
		tmp += symStack.top();
		postfix.push_back(tmp);
		symStack.pop();
	}
}
5、计算后缀表达式

计算后缀表达式，得到最终计算结果，将结果传递到计算器类的result属性。

//计算
void Calculator::calResult() {

	string tmp;
	double number = 0;
	double op1 = 0, op2 = 0;

	for (int i = 0; i < postfix.size(); i++) {
		tmp = postfix[i];
		if (tmp[0] >= '0' && tmp[0] <= '9') {
			number = atof(tmp.c_str());
			figStack.push(number);
		}
		else if (postfix[i] == "+") {
			if (!figStack.empty()) {
				op2 = figStack.top();
				figStack.pop();
			}
			if (!figStack.empty()) {
				op1 = figStack.top();
				figStack.pop();
			}
			figStack.push(op1 + op2);
		}
		else if (postfix[i] == "-") {
			if (!figStack.empty()) {
				op2 = figStack.top();
				figStack.pop();
			}
			if (!figStack.empty()) {
				op1 = figStack.top();
				figStack.pop();
			}
			figStack.push(op1 - op2);
		}
		else if (postfix[i] == "*") {
			if (!figStack.empty()) {
				op2 = figStack.top();
				figStack.pop();
			}
			if (!figStack.empty()) {
				op1 = figStack.top();
				figStack.pop();
			}
			figStack.push(op1* op2);
		}
		else if (postfix[i] == "/") {
			if (!figStack.empty()) {
				op2 = figStack.top();
				figStack.pop();
			}
			if (!figStack.empty()) {
				op1 = figStack.top();
				figStack.pop(); 
			}
			if (op2 != 0) {
				///除数不为0，未做处理，默认
			}
			figStack.push(op1 / op2);
		}
		else if (postfix[i] == "%") {
			if (!figStack.empty()) {
				op2 = figStack.top();
				figStack.pop();
			}
			if (!figStack.empty()) {
				op1 = figStack.top();
				figStack.pop();
			}
			figStack.push(fmod(op1, op2));			//可进行小数求余
		}
		else if (postfix[i] == "^") {
			if (!figStack.empty()) {
				op2 = figStack.top();
				figStack.pop();
			}
			if (!figStack.empty()) {
				op1 = figStack.top();
				figStack.pop();
			}
			figStack.push(pow(op1, op2));
		}
		else if (postfix[i] == "|") {
			if (!figStack.empty()) {
				op1 = figStack.top();
				figStack.pop();
			}
			figStack.push(abs(op1));
		}
		else if (postfix[i] == "!") {
			if (!figStack.empty()) {
				op1 = figStack.top();
				figStack.pop();
			}
			if (op1 > 0) {
				//阶乘数应大于；为小数时(转化为整数求阶)
				double factorial = 1;
				for (int i = 1; i <= op1; ++i)
				{
					factorial *= i;
				}
				op1 = factorial;
			}
			figStack.push(op1);
		}
	}//end for
	if (!figStack.empty()) {
		result = figStack.top();
	}
}
6、对象的外部调用方法
//计算方法
void Calculator::calculate() {

	getFormat();				//表达式自定义标准格式化
	getPostfix();				//后缀表达式转换
	calResult();				//获取算术结果
}

//获取结果
double Calculator::getResult() {
	return result;
}

三、完整代码

Calculator.h: 头文件

//Calculator.h: 头文件
#include <stack>
#include <vector>
#include <string>
using namespace std;

//计算器类
class Calculator
{
public:
	Calculator();
	void getFormat();					//表达式自定义标准格式化
	int getPrior(char c);				//获取算术符号优先级
	void getPostfix();					//后缀表达式转换
	void calResult();					//计算后缀表达式
	void calculate();					//计算方法
	double getResult();					//获取结果

	string operatorSym;					//运算符号
	string infix;						//表达式缓存

private:
	vector<string> postfix;				//后缀表达式向量
	stack<char> symStack;				//符号栈
	stack<double> figStack;				//数字栈
	string stdInfix;					//自定义标准格式化表达式
	double result;						//最终计算结果
};

Calculator.cpp: 实现文件

//Calculator.cpp: 实现文件
#include <stack>
#include <vector>
#include <string>
#include <cmath>
using namespace std;

//绝对值符号个数的奇偶性
enum ABS_ODEVITY {
	ABS_ODD = 1,
	ABS_EVEN = 2,
};

//算术符号优先权等级
enum PRIO_LV {
	PRIO_LV0 = 0,
	PRIO_LV1 = 1,
	PRIO_LV2 = 2,
	PRIO_LV3 = 3,
	PRIO_LV4 = 4,
};

Calculator::Calculator() {				//构造函数，初始化成员变量

	operatorSym = "支持运算符：+, - , *, /, %（百分号）, ^（幂次方）, | |（绝对值），！（阶乘）。其他符号：( ) [ ] { }";
	result = 0.0;
}


//表达式自定义标准格式化
void Calculator::getFormat() {

	stdInfix = infix;

	//实现正负数
	//for (int i = 0; i < stdInfix.length(); i++) {					//string下标调用运算符时可能会导致类型溢出
	for (size_t i = 0; i < stdInfix.size(); i++) {					//string.size()返回size_type类型，避免下标运算时的类型溢出
		if (stdInfix[i] == '-' || stdInfix[i] == '+') {				//-x转换为0-x，+x转化为0+x
			if (i == 0) {
				stdInfix.insert(0, 1, '0');
			}
			else if (stdInfix[i - 1] == '(') {
				stdInfix.insert(i, 1, '0');
			}
		}
	}
}

//获取算术符号优先级
int Calculator::getPrior(char c) {

	if (c == '+' || c == '-') {
		return PRIO_LV1;
	}
	else if (c == '*' || c == '/') {
		return PRIO_LV2;
	}
	else if (c == '%' || c == '^') {
		return PRIO_LV3;
	}
	else if (c == '！') {
		return PRIO_LV4;
	}
	else {
		return PRIO_LV0;
	}
	//else { cout << c << 非法符号！ << endl; }
}

//后缀表达式转换
void Calculator::getPostfix() {

	int absNumeber = ABS_ODD;				//绝对值符号个数的奇偶性
	string tmp;

	//for (int i = 0; i < stdInfix.length(); i++) {
	for (size_t i = 0; i < stdInfix.size(); i++) {					//string.size()返回size_type类型，避免下标运算时的类型溢出
		tmp = "";
		switch (stdInfix[i]) {
		case '+':
		case '-':
		case '*':
		case '/':
		case '%':
		case '^':
		case '!':
			if (symStack.empty() || symStack.top() == '(' || symStack.top() == '[' || symStack.top() == '{' || (symStack.top() == '|' && absNumeber == ABS_ODD)) {
				symStack.push(stdInfix[i]);
			}
			else {
				while (!symStack.empty() && (getPrior(symStack.top()) >= getPrior(stdInfix[i]))) {
					tmp += symStack.top();
					postfix.push_back(tmp);
					symStack.pop();
					tmp = "";
				}
				symStack.push(stdInfix[i]);
			}
			break;
		case '|':
			if (absNumeber == ABS_ODD) {
				symStack.push(stdInfix[i]);
				absNumeber = ABS_EVEN;
			}
			else{
				while (!symStack.empty() && symStack.top() != '|') {
					tmp += symStack.top();
					postfix.push_back(tmp);
					symStack.pop();
					tmp = "";
				}
				if (!symStack.empty() && symStack.top() == '|') {
					tmp += symStack.top();
					postfix.push_back(tmp);						//左绝对值符号'|'加入后缀表达式，用于绝对值的检测计算
					symStack.pop();
					absNumeber = ABS_ODD;
				}
			}
			break;
		case '(':
		case '[':
		case '{':
			symStack.push(stdInfix[i]);
			break;
		case ')':
			while (!symStack.empty() && symStack.top() != '(') {
				tmp += symStack.top();
				postfix.push_back(tmp);
				symStack.pop();
				tmp = "";
			}
			if (!symStack.empty() && symStack.top() == '(') {
				symStack.pop();							//将左括号出栈丢弃
			}
			break;
		case ']':
			while (!symStack.empty() && symStack.top() != '[') {
				tmp += symStack.top();
				postfix.push_back(tmp);
				symStack.pop();
				tmp = "";
			}
			if (!symStack.empty() && symStack.top() == '[') {
				symStack.pop();							//将左括号出栈丢弃
			}
			break;
		case '}':
			while (!symStack.empty() && symStack.top() != '{') {
				tmp += symStack.top();
				postfix.push_back(tmp);
				symStack.pop();
				tmp = "";
			}
			if (!symStack.empty() && symStack.top() == '{') {
				symStack.pop();							//将左括号出栈丢弃
			}
			break;
		default:
			if ((stdInfix[i] >= '0' && stdInfix[i] <= '9')) {
				tmp += stdInfix[i];
				while (i + 1 < stdInfix.length() && (stdInfix[i + 1] >= '0' && stdInfix[i + 1] <= '9' || stdInfix[i + 1] == '.')) {		//小数处理

					tmp += stdInfix[i + 1];			//是连续的数字，则追加
					i++;
				}
				if (tmp[tmp.length() - 1] == '.') {
					tmp += '0';						//将x.做x.0处理
				}
				postfix.push_back(tmp);
			}
			break;
		}//end switch
	}//end for

	//if(!symStack.empty()) {
	while (!symStack.empty()) {						//将栈中剩余符号加入后缀表达式
		tmp = "";
		tmp += symStack.top();
		postfix.push_back(tmp);
		symStack.pop();
	}
}

//计算后缀表达式
void Calculator::calResult() {

	string tmp;
	double number = 0;
	double op1 = 0, op2 = 0;

	for (int i = 0; i < postfix.size(); i++) {
		tmp = postfix[i];
		if (tmp[0] >= '0' && tmp[0] <= '9') {
			number = atof(tmp.c_str());
			figStack.push(number);
		}
		else if (postfix[i] == "+") {
			if (!figStack.empty()) {
				op2 = figStack.top();
				figStack.pop();
			}
			if (!figStack.empty()) {
				op1 = figStack.top();
				figStack.pop();
			}
			figStack.push(op1 + op2);
		}
		else if (postfix[i] == "-") {
			if (!figStack.empty()) {
				op2 = figStack.top();
				figStack.pop();
			}
			if (!figStack.empty()) {
				op1 = figStack.top();
				figStack.pop();
			}
			figStack.push(op1 - op2);
		}
		else if (postfix[i] == "*") {
			if (!figStack.empty()) {
				op2 = figStack.top();
				figStack.pop();
			}
			if (!figStack.empty()) {
				op1 = figStack.top();
				figStack.pop();
			}
			figStack.push(op1* op2);
		}
		else if (postfix[i] == "/") {
			if (!figStack.empty()) {
				op2 = figStack.top();
				figStack.pop();
			}
			if (!figStack.empty()) {
				op1 = figStack.top();
				figStack.pop(); 
			}
			if (op2 != 0) {
				///除数不为0，未做处理，默认
			}
			figStack.push(op1 / op2);
		}
		else if (postfix[i] == "%") {
			if (!figStack.empty()) {
				op2 = figStack.top();
				figStack.pop();
			}
			if (!figStack.empty()) {
				op1 = figStack.top();
				figStack.pop();
			}
			figStack.push(fmod(op1, op2));			//可进行小数求余
		}
		else if (postfix[i] == "^") {
			if (!figStack.empty()) {
				op2 = figStack.top();
				figStack.pop();
			}
			if (!figStack.empty()) {
				op1 = figStack.top();
				figStack.pop();
			}
			figStack.push(pow(op1, op2));
		}
		else if (postfix[i] == "|") {
			if (!figStack.empty()) {
				op1 = figStack.top();
				figStack.pop();
			}
			figStack.push(abs(op1));
		}
		else if (postfix[i] == "!") {
			if (!figStack.empty()) {
				op1 = figStack.top();
				figStack.pop();
			}
			if (op1 > 0) {
				//阶乘数应大于；为小数时(转化为整数求阶)
				double factorial = 1;
				for (int i = 1; i <= op1; ++i)
				{
					factorial *= i;
				}
				op1 = factorial;
			}
			figStack.push(op1);
		}
	}//end for
	if (!figStack.empty()) {
		result = figStack.top();
	}
}

//计算方法
void Calculator::calculate() {

	getFormat();				//表达式自定义标准格式化
	getPostfix();				//后缀表达式转换
	calResult();				//获取算术结果
}

//获取结果
double Calculator::getResult() {
	return result;
}

Main.cpp：主程序

#include <iostream>
using namespace std;

//const int MAX_EXP_LEN = 1000;			//最大表达式长度	防止内存溢出

//main函数
int main()
{
	Calculator cal;
	cout << cal.operatorSym << endl;
	cout << "----------" << endl;

	while (true) {
		getline(cin, cal.infix);
		/*
		if (cal.infix.length() > MAX_EXP_LEN) {
			cout << "超出最大长度！" << endl;
			system("pause");
		}
		else {
			cal.calculate();
		}
		*/
		cal.calculate();
		cout << cal.getResult() << endl;
	}
	return 0;
}

资源获取

Whitemeen太白
关注
  • 133
    点赞
  • 踩
  • 646
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 88
    评论
专栏目录
c++实现计算器
秋城
10-05 3797
  以前写过一个计算器 发表在此博客中(现在已删除)  实现的太过于拉杂,今天再看的时候都不好意思了.代码写的乱七八糟,拉杂不堪,EvaluateExp()看了一会儿都不明白自己是怎吗实现的..估计以前看到这代码的童鞋更加迷茫...嘿嘿.不好意思    昨天写了一个文章,中缀表达式转后缀表达式, http://blog.csdn.net/qiuchengw/archive/2008/1
C++实现计算器
03-30
C++实现的计算器，你能想到的功能都能实现，绝对良心。
c++制作简单计算器
12-11
c++制作简单计算器
使用c++设计一个计算器
最新发布
m0_61862494的博客
06-29 405
使用c++设计一个简单的计算器，它支持不带括号的四则运算，计算器要满足先乘除后加减的规则。这个计算器能够正确处理不带括号的四则运算，并且遵循先乘除后加减的规则。
实现计算器（C++版 ）
热门推荐
weixin_47406709的博客
12-11 1万+
题目： 实现一个计算器，当用户输入1 + 1回车后输出结果为2；当用户输入(5 + 1) % (4 / (3 - 2))输出结果为2。假设输入数字为正整数（输入的数字应该不超过10，记不太清了），且输入无空格。
利用C++完成一个计算器(整体架构+源码)
记录 IT 领域经验与见解的博客
04-07 9597
我们需要考虑计算器的设计思路，实现基本操作、输入和输出、错误处理以及高级功能等模块。在代码实现时，我们可以使用面向对象的方法，将每一个模块封装成一个类，并使用递归、堆栈等数据结构来实现高级功能。在测试和调试时，我们需要编写一些测试用例，测试计算器的各种功能，并进行调试修复问题。例如，我们可以测试加、减、乘、除、取余等基本操作，以及括号、科学计数法、平方根、阶乘等高级功能。在代码实现时，我们可以先实现基本操作功能，再逐步添加高级功能，最后进行测试和调试。1. 基本操作：加、减、乘、除、取余等。
C++ 实现一个简单的计算器 类
12-05
一个简单的计算器类（类型），要求： （1） 从键盘读入算式。 （2） 可以进行加、减、乘、除运算。 （3） 运算要有优先级。 （4） 用户可以按任何的运算符出现顺序进行输入。 （5） 不限定用户输入的计算式的长度。 （6） 可以带有括号()。 （7） 有排错功能，当用户输入错误的算式时提示用户。
C++计算器
weixin_48187130的博客
10-18 1775
很多地方没有优化
用C++编写一个简单的计算器
07-07
用C++编写一个简单的计算器，有代码，可以参考
C++计算器程序 实现了一个计算器的全部功能
05-19
一个用C++实现的计算器的小程序 可以实现 加减乘除运算 可以删除输入的数字
计算器 c++
05-28
c++ 版的计算器，不过有bug，但是不影响使用。主要是想描述栈的运用。可以供初学者学习用。functions头文件里是计算的几个重要函数。
c++ 计算器c++ 计算器c++ 计算器c++ 计算器
03-29
c++ 计算器c++ 计算器c++ 计算器c++ 计算器c++ 计算器c++ 计算器c++ 计算器c++ 计算器c++ 计算器c++ 计算器c++ 计算器c++ 计算器c++ 计算器
c++ 计算器c++ 计算器c++ 计算器c++ 计算器c++ 计算器
03-29
c++ 计算器c++ 计算器c++ 计算器c++ 计算器c++ 计算器c++ 计算器c++ 计算器c++ 计算器c++ 计算器c++ 计算器
数据结构大作业C++实现简单的计算器——算术表达式计算（包含实验报告）
06-25
表达式计算是实现程序设计语言的基本问题之一，也是栈的应用的一个典型例子。设计一个程序，演示用算符优先法对算术表达式求值的过程。 【基本要求】 以字符序列的形式从终端输入语法正确的、不含变量的整数表达式。...
C++课程设计——计算器
12-05
C++课程设计——计算器，可以支持加（+）、减（-）、乘（*）、除（/）运算；支持括号运算，能够判断用户输入的表达式是否正确，若错误，该系统会提示错误，如没有输入左或右操作数；能够判断出除数为0的情况下式子不...
C++课程设计——基于Qt的计算器.zip
09-29
3、如果基础还行，也可在此代码基础上进行修改，以实现其他功能，也可直接用于毕设、课设、作业等。 适用工作项目、毕业设计，课程设计，项目源码均经过助教老师测试，运行无误，轻松复刻，欢迎下载 -------- 下载后...
关联分析——Kendall C++带类实现及案例
05-23
Kendall相关系数是一种用于衡量两个变量之间的关联程度的非参数方法。它通常用于衡量两个变量的排序一致性。在这里，我将提供一个用C++编写的基于类的Kendall相关系数计算程序的实现。 首先，我们需要定义一个类来表示我们要计算的相关系数。这个类应该包含两个变量（可以是数组或向量），以及一个成员函数来计算它们之间的Kendall相关系数。下面是一个可能的实现： ```cpp #include <vector> using std::vector; class KendallCorrelation { public: KendallCorrelation(const vector<int>& x, const vector<int>& y) : x_(x), y_(y) {} double compute() const { int n = x_.size(); int concordant_pairs = 0, discordant_pairs = 0; for (int i = 0; i < n; ++i) { for (int j = i+1; j < n; ++j) { if ((x_[i] < x_[j] && y_[i] < y_[j]) || (x_[i] > x_[j] && y_[i] > y_[j])) { ++concordant_pairs; } else if ((x_[i] < x_[j] && y_[i] > y_[j]) || (x_[i] > x_[j] && y_[i] < y_[j])) { ++discordant_pairs; } } } return (concordant_pairs - discordant_pairs) / static_cast<double>((n*(n-1))/2); } private: vector<int> x_, y_; }; ``` 在这个实现中，我们使用了两个向量来存储我们要计算的变量。构造函数接受这两个向量作为参数，并将它们存储在类的成员变量中。`compute`函数实现了计算Kendall相关系数的算法。它首先计算两个变量中所有可能的配对组合，然后计算这些配对的一致和不一致数量。最后，它返回一致数量和不一致数量之间的差异除以可行配对的总数。 下面是一个示例程序，演示了如何使用这个类来计算两个变量之间的Kendall相关系数： ```cpp #include <iostream> using std::cout; using std::endl; int main() { vector<int> x = {1, 2, 3, 4, 5}; vector<int> y = {5, 4, 3, 2, 1}; KendallCorrelation kendall(x, y); cout << "Kendall correlation: " << kendall.compute() << endl; return 0; } ``` 在这个示例中，我们使用了两个向量x和y，它们分别包含1到5的整数，但是它们是反向排序的。我们创建了一个KendallCorrelation对象，并将x和y向量传递给构造函数。然后，我们调用compute函数来计算它们之间的Kendall相关系数，并将结果打印到控制台上。 这就是一个基于类的Kendall相关系数计算程序的实现和使用示例。如果你有其他问题或需要更多信息，请随时问我。
评论 88
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Whitemeen太白

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值