软件体系结构作业：C++实现KWIC

已于 2023-05-09 08:54:37 修改
阅读量567 收藏 6
点赞数
分类专栏： 软件体系结构 文章标签： c++ 开发语言
于 2023-04-22 09:00:00 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_52709408/article/details/130179404
版权

目录

软件体系结构作业：C++实现KWIC

KWIC(Keywords in context)上下文关键字。按照我的理解就是，给出一些文本即字符串：

  • 首先每行中的字符串按照第一个字母的ASCII大小升序排序
  • 每行排序好之后，文本按照每行中第一个单词的首字母的ASCII大小进行每行的升序排序

输入和输出，既可以在终端（cmd命令行）中实现，也可以从文件中读取文本，转换后输出到文件中。

注释写的很细，因为老师要求的。。。。。看下来应该没有障碍，

主程序子程序实现KWIC

主程序子程序方法，是按照具体实现的功能对构件进行组装，构件以子程序/过程/函数的形式出现。我使用的是子程序+函数，也就是类+函数。每个实现功能的接口（子程序）必须清晰。如果是比较复杂的实现要求，那么首先要进行功能分解，将系统分为高内聚，低耦合的功能模块，进行适当修改后把功能分别用子程序实现。可以使用构造法和子类法实现。

源代码

#include <iostream>
#include<vector>
#include<string>
#include<algorithm>
#include<fstream>
using namespace std;
//因为是子程序主程序实现，所以就不用非得放到类里面
//虽然这样不放到类里面有点乱，但是没办法，毕竟是水博客嘛哈哈哈哈哈哈
//这里的宏定义可以改成自己想创建或者想输出文件的地方
#define  FROM "D:/DEV/in.txt"
#define  TO   "D:/DEV/out.txt"
//全局变量，储存读入和转换后输出的字符串数组
vector<vector<string> > inputarr;
//翻转每一行的字符串数组
bool static sortstring(const vector<string>& s1, const vector<string>& s2)
{
	return s1[0][0] < s2[0][0];
}
//这个是测试用的
//bool static sortstr(const string& s1, const string& s2)
//{
//	return s1[0] < s2[0];
//}
//反转每一行的字符串
void reverseword(vector<string>& s)
{
	for (int i = 0, j = s.size() - 1; i < j; i++, j--)
	{
		swap(s[i], s[j]);
	}
	//测试代码
	//sort(s.begin(), s.end(), sortstr);
	//sort(s.begin(), s.end());
}
class Input
{
public:
	int m, n;
	void input(int m, int n)//设置输入m行每行n列的字符串二维数组
	{//这个地方输入的时候不用非要到输出n个就换行，只要保证能输出m*n个字符串之后回车就可以
		cout << "请输入字符串：" << endl;
		for (int i = 0; i < m; i++)
		{
			vector<string> ans;
			for (int j = 0; j < n; j++)
			{
				string s;
				cin >> s;
				ans.push_back(s);
			}
			inputarr.push_back(ans);
		}
	}
};
class shift
{
public:
	//反转二维数组中每一行的字符串数组
	void shiftstring()
	{
		for (int i = 0; i < inputarr.size(); i++)
		{
			reverseword(inputarr[i]);
		}
	}
};
class alphabetizer
{
public:
	//在每行排好序之后，按照数组中每行的第一个单词的第一个字母给二维数组排序
	void alphastring()
	{
		sort(inputarr.begin(), inputarr.end(), sortstring);
	}
};
class output
{
public:
	//将转换好的数组循环输出到命令行
	void outputarr()
	{
		for (int i = 0; i < inputarr.size(); i++)
		{
			for (int j = 0; j < inputarr[i].size(); j++)
			{
				cout << inputarr[i][j] << " ";//此处要将输出每个单词后加入空行
			}
			cout << endl;//每行字符串输出后换行
		}
	}
};
//下面是读入写出到文件的
//trimstr是将从文件中读入的数据按照空格进行切割。切割后放入储存每行字符串的数组
void trimstr(string& s, vector<string>& target)
{
	string res;
	for (int i = 0; i < s.size(); i++)
	{
		if (s[i] != ' ')res += s[i];
		else
		{
			target.push_back(res);
			res.clear();
		}
	}
	target.push_back(res);
}
//mergestr是用来将处理好的字符串转换成每行的形式，便于之后可以通过一次循环重定向到目标文件
void mergestr(string& s, vector<string>& target)
{
	for (int i = 0; i < target.size(); i++)
	{
		s += target[i];
		s += ' ';
	}
	s.pop_back();
}
//从文件中读入数组到二维数组中
void Readfile(vector < vector<string>>& ans)
{
	ifstream Input;
	Input.open(FROM);//打开已经宏定义的文件路路径
	string s;
	vector<string>res;
	//储存文件中的字符串数组
	if (Input.is_open())
	{
		while (getline(Input, s))
		{
			trimstr(s, res);//分割每行数组
			ans.push_back(res);//分割好的数组放到整个储存文本的数组中
			res.clear();
			s = "";//清空s数据，重新记录，s.clear()也可以
		}
	}
	//测试输出成功
	/*for (auto a : ans)
	{
		for (auto ii : a)
		{
			cout << ii << " ";
		}
		cout << endl;
	}*/
	Input.close();
}
//将转换好的字符串重组后重定向到目标文件中
void Writefile(vector < vector<string>>& ans)
{
	ofstream Myfile;
	Myfile.open(TO);
	string s;
	vector<string>res;
	//储存文件中的字符串数组
	if (Myfile.is_open())
	{
		for (int i = 0; i < ans.size(); i++)
		{
			mergestr(s, ans[i]);
			Myfile << s;
			Myfile << "\n";
			s.clear();
		}
	}
	//测试输出成功
	Myfile.close();
}
//实现文件层面的输出输出的KWIC
void testforfile()
{
	Readfile(inputarr);
	shift shiftt;
	shiftt.shiftstring();
	alphabetizer Alpha;
	Alpha.alphastring();
	Writefile(inputarr);
}
//实现命令行上的输入输出KWIC，从终端输入的字符串文本作文输入，经过转换之后输出到终端
void testforcommand()
{
	int m, n;
	cout << "请输入行数：";
	cin >> m;
	cout << "请输入每行字符串的个数：";
	cin >> n;
	Input num;
	num.m = m;
	num.n = n;
	num.input(num.m, num.n);
	cout << "您输入的字符串数组为:" << endl;
	for (int i = 0; i < inputarr.size(); i++)
	{
		for (int j = 0; j < inputarr[i].size(); j++)
		{
			cout << inputarr[i][j] << " ";
		}
		cout << endl;
	}
	cout << "--------------------------------" << endl;
	shift Shift;
	Shift.shiftstring();
	alphabetizer alpha;
	alpha.alphastring();
	output outputstring;
	outputstring.outputarr();
}
int main(int argc, char** argv) {
	testforcommand();
	//testforfile();
	return 0;
}

终端方法运行结果

在这里插入图片描述

管道过滤器实现KWIC

听到管道过滤器首先想到的就是Linux里面的管道pipe函数和“|”，犹记得当初学Linux的时候经常ps aux|grep pid.管道过滤器实现是把运行程序比作一个管道，管道的两个口相当于是输入输出。构件输入数据到管道，管道把输入的数据流进行处理，这里称为“过滤”。而后传输到管道出口。管道过滤器值得注意的是管道过滤器必须是实体，不能与其他过滤器共享数据。一个管道输出的正确性并不依赖于过滤器的多少以及计算顺序

源代码

#include <iostream>
using namespace std;
#include<vector>
#include<string>
#include<algorithm>
#include<fstream>
//这里的宏定义可以改成自己想创建或者想输出文件的地方
#define  FROM "D:/DEV/in.txt"
#define  TO   "D:/DEV/out.txt"
//全局变量，储存读入和转换后输出的字符串数组
vector<vector<string> > inputarr;
//sortstring是反转矩阵中一行字符串的规则，回调函数
bool static sortstring(const vector<string>& s1, const vector<string>& s2)
{
	return s1[0][0] < s2[0][0];
}
//这个是测试用的
//bool static sortstr(const string& s1, const string& s2)
//{
//	return s1[0] < s2[0];
//}
class Input
{
public:
	int m, n;
	//trimstr是将从文件中读入的数据按照空格进行切割。切割后放入储存每行字符串的数组
	void trimstr(string& s, vector<string>& target)
	{
		string res;
		for (int i = 0; i < s.size(); i++)
		{

			if (s[i] != ' ')res += s[i];
			else//遇到空格就将之前放好的字符串加入数组
			{
				target.push_back(res);
				res.clear();
			}
		}
		target.push_back(res);
	}
	//设置从命令行输入m行每行n列的字符串储存到二维数组
	void input(int m, int n)
	{
		cout << "请输入" << m <<"行" << n <<"列的字符串"<< endl;//如果测试的时候这个乱码就用下面这一行
		//cout << "start input " << m << "X" << n << "string array please" << endl;
		for (int i = 0; i < m; i++)
		{
			vector<string> ans;
			for (int j = 0; j < n; j++)
			{
				string s;
				cin >> s;
				ans.push_back(s);
			}
			inputarr.push_back(ans);
		}
	}
	//从文件中读入数组到二维数组中
	void Readfile(vector < vector<string>>& ans)
	{
		ifstream Input;
		Input.open(FROM);//打开已经宏定义的文件路路径
		string s;
		vector<string>res;
		//储存文件中的字符串数组
		if (Input.is_open())
		{
			while (getline(Input, s))
			{
				trimstr(s, res);//分割每行数组
				ans.push_back(res);//分割好的数组放到整个储存文本的数组中
				res.clear();
				s = "";//清空s数据，重新记录，s.clear()也可以
			}
		}
		//测试输出成功
		/*for (auto a : ans)
		{
			for (auto ii : a)
			{
				cout << ii << " ";
			}
			cout << endl;
		}*/
		Input.close();
	}
};
class Output {
public:
	//mergestr是用来将处理好的字符串转换成每行的形式，便于之后可以通过一次循环重定向到目标文件
	void mergestr(string& s, vector<string>& target)
	{
		for (int i = 0; i < target.size(); i++)
		{
			s += target[i];
			s += ' ';
		}
		s.pop_back();
	}
	//将转换好的数组循环输出到命令行
	void outputarr()
	{
		cout << "转换后的数组为：" << endl;
		for (int i = 0; i < inputarr.size(); i++)
		{
			for (int j = 0; j < inputarr[i].size(); j++)
			{
				cout << inputarr[i][j] << " ";//此处要将输出每个单词后加入空行
			}
			cout << endl;
		}
	}
	//将转换好的字符串重组后重定向到目标文件中
	void Writefile(vector < vector<string>>& ans)
	{
		ofstream Myfile;
		Myfile.open(TO);
		string s;
		vector<string>res;
		//储存文件中的字符串数组
		if (Myfile.is_open())
		{
			for (int i = 0; i < ans.size(); i++)
			{
				mergestr(s, ans[i]);
				Myfile << s;//每行重定向到文件
				Myfile << "\n";//每行输出到文件之后要换行
				s.clear();
			}
		}
		//测试输出成功
		Myfile.close();
	}
};
class Move
{
public:
	//反转每一行的字符串
	void reverseword(vector<string>& s)
	{
		for (int i = 0, j = s.size() - 1; i < j; i++, j--)
		{
			swap(s[i], s[j]);
		}
		//测试代码
		//sort(s.begin(), s.end(), sortstr);
		//sort(s.begin(), s.end());
	}
	//反转二维数组中每一行的字符串数组
	void move()
	{
		for (int i = 0; i < inputarr.size(); i++)
		{
			reverseword(inputarr[i]);
		}
	}
};
class Order
{
public:
	//在每行排好序之后，按照数组中每行的第一个单词的第一个字母给二维数组排序
	void order()
	{
		sort(inputarr.begin(), inputarr.end(), sortstring);
	}
};
//控制输出端和输出端，实现KWIC从输入端文件到输出端文件，类似Linux中的pipe管道
class Pipe
{
public:
	//实现命令行上的输入输出KWIC，从终端输入的字符串文本作文输入，经过转换之后输出到终端
	void testforcommand()
	{
		int m, n;
		cout << "请输入行数";
		cin >> m;
		cout << "请输入每行字符串的数量";
		cin >> n;
		Input num;
		num.m = m;
		num.n = n;
		num.input(num.m, num.n);
		//测试输入是否成功
		/*cout << "您输入的字符串数组为：" << endl;
		for (int i = 0; i < inputarr.size(); i++)
		{
			for (int j = 0; j < inputarr[i].size(); j++)
			{
				cout << inputarr[i][j] << " ";
			}
			cout << endl;
		}
		cout << "--------------------------------" << endl;*/
		Move mo;
		mo.move();
		Order alpha;
		alpha.order();
		Output outputstring;
		outputstring.outputarr();
	}
	//实现文件层面的输出输出的KWIC
	void testforfile()
	{
		Input inn;
		inn.Readfile(inputarr);
		Move mo;
		mo.move();
		Order alpha;
		alpha.order();
		Output outputstring;
		outputstring.outputarr();
		Output outt;
		outt.Writefile(inputarr);
	}
};
int main(int argc, char** argv) {
	Pipe pip;
	//pip.testforcommand();
	//pip.testforfile();
	return 0;
}

终端方法运行结果

在这里插入图片描述

面向对象风格实现KWIC

抽象数据类型概念对软件系统有着重要作用，目前软件界已普遍转向使用面向对象系统。这种风格建立在数据抽象和面向对象的基础上，数据的表示方法和它们的相应操作封装在一个抽象数据类型或对象中。这种风格的构件是对象，或者说是抽象数据类型的实例。对象是一种被称作管理者的构件，因为它负责保持资源的完整性。对象是通过函数和过程的调用来交互的。
面向对象风格的优缺点：

  • 因为对象对其它对象隐藏它的表示，所以可以改变一个对象的表示，而不影响其它的对
    象
  • 设计师可将一些数据存取操作的问题分解成一些交互的代理程序的集合
    但是，面向对象的系统也存在着某些问题:
  • 为了使一个对象和另一个对象通过过程调用等进行交互，必须知道对象的标识。只要一个对象的标识改变了，就必须修改所有其他明确调用它的对象
  • 必须修改所有显式调用它的其它对象，并消除由此带来的一些副作用。例如，如果A使用了对象B，C也使用了对象B，那么，C对B的使用所造成的对A的影响可能是料想不到的

因为不知道能不能用全局变量存储执行结果，在这里我是觉得不能使用全局变量的，所以在每个类中创建一个成员变量存储每个类成员函数执行之后的结果

源代码

#include <iostream>
#include<vector>
#include<string>
#include<algorithm>
#include<fstream>
using namespace std;
//这里的宏定义可以改成自己想创建或者想输出文件的地方
#define  FROM "D:/DEV/in.txt"
#define  TO   "D:/DEV/out.txt"
//这个是测试用的
//bool static sortstr(const string& s1, const string& s2)
//{
//	return s1[0] < s2[0];
//}
class Input
{
public:
	int m, n;
	vector<vector<string> > inputarr;
	void inputdata()//设置输入m行每行n列的字符串二维数组
	{
		cout << "请输入行数：";
		cin >> m;
		cout << "请输入每行字符串的个数：";
		cin >> n;
		//这个地方输入的时候不用非要到输出n个就换行，只要保证能输出m*n个字符串之后回车就可以
		cout << "请输入字符串：" << endl;
		for (int i = 0; i < m; i++)
		{
			vector<string> ans;
			for (int j = 0; j < n; j++)
			{
				string s;
				cin >> s;
				ans.push_back(s);
			}
			inputarr.push_back(ans);
		}
	}
};
class Shift
{
public:
	vector<vector<string> > inputarr;
	Shift(vector<vector<string> > inputarr):inputarr(inputarr){}
	Shift(){}
	//翻转每一行的字符串数组
	void reverseword(vector<string>& s)
	{
		for (int i = 0, j = s.size() - 1; i < j; i++, j--)
		{
			swap(s[i], s[j]);
		}
		//测试代码
		//sort(s.begin(), s.end(), sortstr);
		//sort(s.begin(), s.end());
	}
	//反转二维数组中每一行的字符串数组
	void shiftstring()
	{
		for (int i = 0; i < inputarr.size(); i++)
		{
			reverseword(inputarr[i]);
		}
	}
};
class Alphabetizer
{
public:
	vector<vector<string> > inputarr;
	Alphabetizer(vector<vector<string> > inputarr) :inputarr(inputarr) {}
	Alphabetizer(){}
	//给二维数组进行行排序
	bool static sortstring(const vector<string>& s1, const vector<string>& s2)
	{
		return s1[0][0] < s2[0][0];
	}
	//在每行排好序之后，按照数组中每行的第一个单词的第一个字母给二维数组排序
	void alphastring()
	{
		sort(inputarr.begin(), inputarr.end(), sortstring);
	}
};
class Output
{
public:
	vector<vector<string> > inputarr;
	Output(vector<vector<string> > inputarr) :inputarr(inputarr) {}
	Output(){}
	//将转换好的数组循环输出到命令行
	void outputarr()
	{
		for (int i = 0; i < inputarr.size(); i++)
		{
			for (int j = 0; j < inputarr[i].size(); j++)
			{
				cout << inputarr[i][j] << " ";//此处要将输出每个单词后加入空行
			}
			cout << endl;//每行字符串输出后换行
		}
	}
};
//下面是读入写出到文件的
class FileInput
{
public:
	vector<vector<string> > inputarr;
	//trimstr是将从文件中读入的数据按照空格进行切割。切割后放入储存每行字符串的数组
	void trimstr(string& s, vector<string>& target)
	{
		string res;
		for (int i = 0; i < s.size(); i++)
		{

			if (s[i] != ' ')res += s[i];
			else
			{
				target.push_back(res);
				res.clear();
			}
		}
		target.push_back(res);
	}
	//从文件中读入数组到二维数组中
	void Readfile()
	{
		ifstream Input;
		Input.open(FROM);//打开已经宏定义的文件路路径
		string s;
		vector<string>res;
		//储存文件中的字符串数组
		if (Input.is_open())
		{
			while (getline(Input, s))
			{
				trimstr(s, res);//分割每行数组
				inputarr.push_back(res);//分割好的数组放到整个储存文本的数组中
				res.clear();
				s = "";//清空s数据，重新记录，s.clear()也可以
			}
		}
		//测试输出成功
		/*for (auto a : ans)
		{
			for (auto ii : a)
			{
				cout << ii << " ";
			}
			cout << endl;
		}*/
		Input.close();
	}
};
class FileOutput
{
public:
	vector<vector<string> > inputarr;
	FileOutput(vector<vector<string> > inputarr):inputarr(inputarr){}
	//mergestr是用来将处理好的字符串转换成每行的形式，便于之后可以通过一次循环重定向到目标文件
	void mergestr(string& s, vector<string>& target)
	{
		for (int i = 0; i < target.size(); i++)
		{
			s += target[i];
			s += ' ';
		}
		s.pop_back();
	}
	//将转换好的字符串重组后重定向到目标文件中
	void Writefile()
	{
		ofstream Myfile;
		Myfile.open(TO);
		string s;
		vector<string>res;
		//储存文件中的字符串数组
		if (Myfile.is_open())
		{
			for (int i = 0; i < inputarr.size(); i++)
			{
				mergestr(s, inputarr[i]);
				Myfile << s;
				Myfile << "\n";
				s.clear();
			}
		}
		//测试输出成功
		Myfile.close();
	}
};


//实现文件层面的输出输出的KWIC
void testforfile()
{
	FileInput input;
	input.Readfile();
	Shift shift(input.inputarr);
	shift.shiftstring();
    Alphabetizer alpha(shift.inputarr);
	alpha.alphastring();
	FileOutput output(alpha.inputarr);
	output.Writefile();
}
//实现命令行上的输入输出KWIC，从终端输入的字符串文本作文输入，经过转换之后输出到终端
void testforcommand()
{
	/*int m, n;
	cout << "请输入行数：";
	cin >> m;
	cout << "请输入每行字符串的个数：";
	cin >> n;*/
	Input inputstring;
	inputstring.inputdata();
	/*cout << "您输入的字符串数组为:" << endl;
	for (int i = 0; i < num.inputarr.size(); i++)
	{
		for (int j = 0; j < num.inputarr[i].size(); j++)
		{
			cout << num.inputarr[i][j] << " ";
		}
		cout << endl;
	}
	cout << "--------------------------------" << endl;*/
	Shift shift(inputstring.inputarr);
	shift.shiftstring();
	Alphabetizer alpha(shift.inputarr);
	alpha.alphastring();
	Output outputstring(alpha.inputarr);
	outputstring.outputarr();
}
int main(int argc, char** argv) {
	//testforcommand();
	testforfile();
	return 0;
}

运行结果

在这里插入图片描述

个人感想

实际上，不同结构实现的KWIC只是结构不同而已，核心代码没有变。老师给我们的这个案例只是让我们更加理解这些软件体系结构的。不过之前了解KWIC的时候发现KWIC有8种实现方式之多！另外网上基本上都是Java写的代码，虽然能看懂，但是有些费劲。用C++写的KWIC，我个人觉得也没有那么好，正好老师布置了这个作业，那正好水一下博客hhhhhhh
说实话我没感觉面向对象和主程序子程序有什么太大的区别，可能面向对象就是把操作/方法（子程序）封装成类了，所有的操作都是通过类对象的方法传递信息的。

ICE2302
关注
  • 0
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
基于管道过滤器的KWIC系统实现（4）
^-^
12-05 2万+
package lws; import java.io.CharArrayWriter;import java.io.IOException;import java.util.ArrayList;import java.util.Iterator; public class LineTransformer extends Filter{  public LineTransformer(Pipe i
KWIC体系结构代码实现
12-18
KWIC问题的具体代码实现，包括管道过滤器、基于事件调用、主程序子过程等共五种体系结构风格
八种软件结构风格的KWIC系统实现以及设计图和要求
01-17
八种软件结构风格的KWIC系统实现以及设计图和要求,连带说明PPT，也是高校的软件体系结构作业。。。
三种架构风格实现KWIC
02-04
压缩包中的工程包含了三种风格。adtstyle文件夹对应的是抽象数据风格，invretstyle文件夹对应的是调用返回风格，pipestyle文件夹对应的是管道过滤器风格。源代码是用MyEclipse 6.5写的。可直接将工程导入MyEclipse中即可运行，也可以运行SA文件夹里面的start.bat选择某个风格运行。 抽象数据风格的按字母排序算法用的是快速排序算法，代码位于SA\src\adtstyle\impl.AlphabetizerImpl.java，调用返回风格用的是插入排序算法，代码位于SA\src\invretstyle\Alphabetizer.java，管道过滤器风格用的是堆排序算法，代码位于SA\src\pipestyle\Alphabetizer.java。三种风格都对一些噪音词汇进行过滤，private static final String ignore = "a#$an#$and#$as#$is#$the#$of#$"，上面语句中由"#$"间隔开的就是噪音词汇。SA\input.txt是输入文件，可对其进行配置来解析不同的文本。
KWIC_问题_软件体系结构作业
07-20
KWIC 问题_软件体系结构作业 KWIC作为一个早年间在ACM的Paper提出的一个问题，被全世界各个大学的软件设计课程奉为课堂讲义或者作业的经典。（From Wiki，FYI，D. L. Parnas uses a KWIC Index as an example on how to perform modular design in his paper "On the Criteria To Be Used in Decomposing Systems into Modules" - Available as ACM Classic Paper）
KWIC:Key Word in Context (KWIC) 系统的 Matlab 实现。-matlab开发
05-29
这是 Key Word In Context (KWIC) 系统的 Matlab 实现，如 David L. Parnas 的论文“On the Criteria To Be Used in Decomposing Systems into Modules”（1972）中的“Modularization 1”所述
KWIC系统事件系统结构实现
03-07
KWIC系统基于事件体系结构的java实现，实现字符串的拆分、排序、单词统计功能。
KWIC 程序示例 （关键字检索程序）
07-29
关键字检索是软件体系结构的一个经典案例,这里给出了一个程序示例.本例采用使用共享数据的主程序/子程序结构，根据四个基本功能将问题分解为：输入、移动、按字母表排序、输出。所有计算构件作为子程序协同工作并且由一个主程序顺序地调用这些子程序。构件通过共享存储区交换数据。因为协同工作的子程序能够保证共享数据的顺序因此使计算构件和共享数据之间基于一个不受约束的读写协议的通信成为可能。
语料库数据处理个案实例（计算机搭配强度、删除表中的停用词、词料检索的KWIC实现）
Triumph19的博客
06-22 1584
语料库数据处理个案实例
主程序-子程序、面向对象、事件系统和管道-过滤软件体系结构实现KWIC
weixin_43853097的博客
12-09 9104
KWIC(Key Word In Context)，Parnas (1972)索引系统 KWIC索引系统接受一些行，每行有若干字，每个字由若干字符组成；每行都可以循环移位，亦即重复地把第一个字删除，然后接到行末； KWIC把所有行的各种移位情况按照字母表顺序输出（不考虑大小写）。 输入：若干行字符语句 The sun is rising in the east Flowers are blooming 中间过程：循环移位后形成下面的结果 The sun is rising in the eas
KWIC 软件系统行为型设计模式应用 -- 观察者模式
qq_43071318的博客
11-18 1286
Alphabetizer.java: import java.io.IOException; import java.util.ArrayList; import java.util.Collections; public class Alphabetizer implements KWICListener{ private TextLines textlines=null; @Override public void handleEvent(KWICEvent event) { // TOD
KWIC：作业1：OO KWIC
02-11
作业1：OO KWIC 学生：蒙特罗杰斯（MR3575） 课程：SE 575：软件架构，2020-2021年冬季 日期：1/25/2021
分析比较KWIC系统实现四种不同体系结构风格.pdf
03-31
分析比较KWIC系统实现四种不同体系结构风格.pdf分析比较KWIC系统实现四种不同体系结构风格.pdf分析比较KWIC系统实现四种不同体系结构风格.pdf分析比较KWIC系统实现四种不同体系结构风格.pdf分析比较KWIC系统实现四种...
软件体系结构KWIC实验.doc
09-29
软件体系结构KWIC实验.doc
C++教学——从入门到精通 10.循环
QIPABOSHI的博客
04-24 358
一些事嘛，需要重复做，这就是循环在开始学之前我提一个事，最好先学Python再学C++，不然就会像我和piaojunhe_0825一样有C++后遗症，在Python里写了一个for(int i=0;i
C++ WebServer的细节理解
我的博客
04-22 602
在非阻塞模式下，如果 I/O 操作不能立即完成（例如，因为没有数据可读 或 写缓冲区满），系统不会让调用进程阻塞等待，而是立即返回一个错误（通常为 EAGAIN 或 EWOULDBLOCK）。先查询文件描述符 fd 当前的标志，然后将 O_NONBLOCK 标志加入其中，并通过 F_SETFL 来更新文件描述符，最终实现将该文件描述符切换为非阻塞模式。这意味着，如果没有待处理的连接请求（即没有客户端尝试连接到服务器），accept() 会一直阻塞，直到有新的连接请求到达或发生其他特定条件（如超时）为止。
C++——初识模板
qq_74245477的博客
04-22 897
之前实现的数据结构，比如栈，我们为了便于修改存储的数据类型，通常使用typedef来重定义数据类型，但是这样有一个缺陷，会导致我们定义的栈存储的都是一种数据，如果同时需要两个栈，一个存储int，一个存储自定义类型，那么typedef就不管用了。比如：当用int类型使用函数模板时，编译器通过对实参类型的推演，将T确定为int类型，然后产生一份专门处理int类型的代码，对于字符类型也是如此。概念：函数模板代表了一个函数家族，该函数模板与类型无关，在使用时被参数化，根据实参类型产生函数的特定类型的版本。
C 练习实例36 - 求100之内的素数
最新发布
2401_82561004的博客
04-27 809
质数（prime number）又称素数，有无限个。一个大于1的自然数，除了1和它本身外，不能被其他自然数整除。// Copyright © 2013年 编程字典. All rights reserved.求100之内的素数。
理解C语言中的位操作和整数类型：一个温度传感器读取问题的解析
qq_61637982的博客
04-24 229
当我们编写嵌入式系统的代码时，我们经常需要使用位操作来处理硬件设备的数据。然而，如果我们对C语言的位操作和整数类型不完全理解，可能会遇到一些难以理解的问题。在这篇博客中，我将通过一个实际的例子来解释这些概念，并提供一个解决方案。
请用JAVA语言根据采用调用返回风格中的面向对象体系结构风格实现KWIC关键词索引系统，写下完整代码
04-23
2. 在使用调用返回风格和面向对象体系结构风格实现KWIC关键词索引系统时，您可以选用一种流行的JAVA框架，例如Spring或Spring Boot，这些框架可以帮助您快速建立面向对象的应用程序。 3. 您还可以借助一些相关的...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值