程序员经验分享-hwhale

数据压缩学习实验（四）LZW压缩算法的C++实现及其效率分析

2023-11-13

实验目的：

掌握词典编码的基本原理，阅读C语言实现的LZW算法并用C++按自己理解实现LZW解码器并分析编解码算法，以及LZW算法对不同文件的压缩效果。

LZW算法原理：

关于更具体的图解LZW编解码可以参考：超级简单的数据压缩算法—LZW算法

编码部分：

在这里插入图片描述
简单地讲，LZW的编码就是不断将目前字符‘c’与上一个字符串P串成一个新串，并与词典中已有串进行不断比对，若新串P+‘c’在词典中，则将P+‘c’的索引赋给P并读取下一个字符；若P+‘c’不在词典中，则发送码字P的索引，并将P+‘c’写入词典。该算法压缩任何文件时均以字符串的形式读入数据。
注：原理上是这样解释，但在编程时有个坑，在C++中使用fstream操作文件流时仍需按ios::binary形式打开文件，否则会遇到读入的时候若读到与EOF相同的字节程序会认为文件结束，从而引发错误。这里读入一个字符更准确的解释是读入一个unsigned char型数据。

以下是教材中对于LZW编码的解释：

LZW编码原理和实现算法
LZW的编码思想是不断地从字符流中提取新的字符串，通俗地理解为新“词条”，然后用“代号”也就是码字表示这个“词条”。这样一来，对字符流的编码就变成了用码字去替换字符流，生成码字流，从而达到压缩数据的目的。LZW编码是围绕称为词典的转换表来完成的。LZW编码器通过管理这个词典完成输入与输出之间的转换。LZW编码器的输入是字符流，字符流可以是用8位ASCII字符组成的字符串，而输出是用N位(例如12位)表示的码字流。LZW编码算法的步骤如下：
步骤1：将词典初始化为包含所有可能的单字符，当前前缀P初始化为空。
步骤2：当前字符C=字符流中的下一个字符。
步骤3：判断P＋C是否在词典中
（1）如果“是”，则用C扩展P，即让P=P＋C，返回到步骤2。
（2）如果“否”，则
输出与当前前缀P相对应的码字W；
将P＋C添加到词典中；
令P=C，并返回到步骤2

解码部分：

在这里插入图片描述
对于LZW的解码，可以认为是这样的：解码器不断接收新的码字索引，根据索引查得当前码字C，并将每一个新码字C的第一个字符C[0]与上一个码字P组合成一个新的码字加入字典。
需要注意的是，新码字索引C有可能会不在词典当中。当编码端对类似ABABABA这样具有对称性的字符串进行编码时，会出现如接收端接收到230号码字但实际词典中只有0-299号码字。在这种情况下，根据LZW算法的编码原理，可推知230号码字由299号码字串接230号码字的第一个字符组成，于是，230号码字为299号码字+299号码字中的第一个字符，完成对230号码字的解码。

以下是教材中对于LZW编码的解释：

LZW解码原理和实现算法 LZW解码算法开始时，译码词典和编码词典相同，包含所有可能的前缀根。具体解码算法如下：
步骤1：在开始译码时词典包含所有可能的前缀根。
步骤2：令CW：=码字流中的第一个码字。
步骤3：输出当前缀-符串STRING.CW到码字流。
步骤4：先前码字PW：=当前码字CW。
步骤5：当前码字CW：=码字流的下一个码字。
步骤6：判断当前缀-符串STRING.CW 是否在词典中。
（1）如果”是”，则把当前缀-符串STRING.CW输出到字符流。
当前前缀P：=先前缀-符串STRING.PW。
当前字符C：=当前前缀-符串STRING.CW的第一个字符。
把缀-符串P+C添加到词典。
（2）如果”否”，则当前前缀P：=先前缀-符串STRING.PW。
当前字符C：=当前缀-符串STRING.CW的第一个字符。
输出缀-符串P+C到字符流,然后把它添加到词典中。
步骤7：判断码字流中是否还有码字要译。
（1）如果”是”，就返回步骤4。
（2）如果”否”，结束。

数据结构：

在这里插入图片描述
词典采用动态建立的树的结构，便于查找。
每个节点包含信息如下：

内容 大小
尾缀字符（suffix） 1Byte
母节点（parent） 1Byte
第一个孩子节点( firstchild ) 1Byte
下一个兄弟节点（nextsibling） 1Byte

树中的每一个结点包含如下信息：尾缀字符（suffix）、母节点（parent）、第一个孩子节点( firstchild )、下一个兄弟节点（nextsibling）。
词典的初始化：初始化0-255号条目，每个条目的尾缀字符suffix就是其索引号，下一个兄弟结点nextsibling为其索引+1（第255号的nextsibling为-1，即不存在），每一项的母结点parent、第一个孩子结点firstchild均为-1，表示不存在。
词典的查找：在查找时某个码字m加上前缀c是否存在于词典中时，先访问码字m，根据码字m的firstchild查找到第一个子节点，根据该子节点及其兄弟结点nextsibling依次访问，便可查找以码字m为前缀的所有词条，若存在，则返回该结点索引，若不存在，返回-1。
词典的添加：将m+‘c’添加进词典。添加时有两种情况，其一，若m没有子节点firstchild，则将‘c’作为其子节点；若m存在子节点，则沿着第一个子节点的兄弟结点nextsibling依次访问，直至末尾，将‘c’添加至该末尾。

此外，为便于解压，需要向压缩后的文件写入原始文件大小。本次实验的程序中所编写的程序每一个码字为2Byte，范围0-65535。

实验素材：

测试LZW压缩效果的文件有：

  1. 未经压缩的bmp图像文件
  2. YUV图像文件
  3. 文本文件
  4. 经过压缩的png图像文件
  5. 经过压缩的jpg图像文件
  6. 无损压缩flac音频文件
  7. 有损压缩mp3音频文件
  8. 索尼相机arw RAW图像文件
  9. exe程序文件
  10. word文档文件
  11. pdf文件

实验中所使用的文件并不能很好地代表一般情况

实验结果：

测试用文本文件“in.txt”:
在这里插入图片描述
二进制表示：
在这里插入图片描述
压缩后结果：
在这里插入图片描述
解压结果：
在这里插入图片描述
可见，由于一个码字使用16bit表示，在压缩小文件时文件体积不减反增。

对不同种类文件压缩的结果：

文件 说明 输入字节数 输出字节数 压缩率
test1.bmp 8bit有调色板bmp文件 308278 224122 72.7%
test2.bmp 24bit真彩色bmp文件 196664 189832 96.5%
test3.png 经过压缩编码的PNG文件 163978 219674 140.0%
test4.jpg 经过压缩编码的JPG文件 24200 40796 168.6%
miss.cif 未经压缩的YUV文件 3649536 2161456 59.2%
text_test.txt 未经压缩的文本文件 4723 3960 83.8%
flac_test.flac 无损音频flac文件 39745636 49351988 124.2%
mp3_test.mp3 有损音频mp3文件 12158251 15113846 124.3%
arw_test.arw 索尼相机arw RAW图像文件 24674304 29674756 120.3%
devenv.exe exe程序文件 747952 650210 87.0%
docx_test.docx word文档文件 21954 34434 156.8%
pdf_test.pdf pdf文件 2357605 2791542 118.4%

结果分析

  1. 实验中的编码由于一个码字为2Byte，所以在传送255以内的码字时会浪费1Byte，造成编码效率下降。
  2. 从不同文件的压缩结果可以看出，对于未压缩的文件，LZW算法可以进行一定程度的压缩，文件中数据的冗余度越高，压缩性能越好，如一个24fps的CIF分辨率420采样YUV文件，由于每一帧之间存在较高相关性，而且帧内相邻像素之间存在一定相关性，因此获得了比较好的压缩效果。
  3. 对于未经压缩的BMP文件，由于相邻像素间存在相关性，仍然可以获得一定的压缩效果。
  4. LZW算法存在固有限制：字符串重复概率低时，影响压缩效率；词典中的字符串不再出现，影响压缩效率。对于已经压缩的文件类型，由于其压缩编码已经文件中大部分相关性去除，每个符号近似于等概分布，其信息熵接近于每符号最大值。在这种情况下文件中很少出现重复字符串，严重影响LZW算法效率，且一个码字为2Byte使得文件体积不减反增。

程序代码

lzw.h

#pragma once
#include "bitio.h"
#include <iostream>
#include <fstream>
#define MAX_size 65535
using namespace std;

typedef unsigned char uint1;
typedef unsigned short uint2;
typedef unsigned int uint4;

bool LZWencode(ifstream& file_in, BitFileOut& bit_out);
bool LZWdecode(ofstream& file_out, BitFileIn& bit_in);

class LZW_Dictionary
{
public:
	LZW_Dictionary();
	~LZW_Dictionary();
	void initDictionary();
	int InDict(uint1 character, int string_code);
	void AddtoDict(uint1 character, int string_code);
	void PrintDict();
	int get_next_code();
	int DecodeString(int code, int last_code, int start = 0);

	uint1* d_stack;

private:
	typedef struct {
		int suffix;
		int parent;
		int firstchild;
		int nextsibling;
	}node;
	node* dict;
	uint4 next_code;
};

lzw.cpp

#include "lzw.h"
#include <iostream>
using namespace std;

LZW_Dictionary::LZW_Dictionary()
{
	initDictionary();
}

LZW_Dictionary::~LZW_Dictionary()
{
	delete[] dict;
	delete[] d_stack;
}

void LZW_Dictionary::initDictionary()
{
	dict = new node[MAX_size + 1];
	d_stack = new uint1[MAX_size];
	for (int i = 0; i < 256; i++) {
		dict[i].suffix = i;
		dict[i].parent = -1;
		dict[i].firstchild = -1;
		dict[i].nextsibling = i + 1;
	}
	dict[255].nextsibling = -1;
	next_code = 256;
}

int LZW_Dictionary::InDict(uint1 character, int string_code)
{
	//using -1 to show string_code is null
	int sibling;
	if (string_code < 0) { return character; }
	sibling = dict[string_code].firstchild;

	while (sibling > -1) {
		if(dict[sibling].suffix == character){
			return sibling;  //find
		}
		sibling = dict[sibling].nextsibling;  //search the next
	}
	return -1;  //not find
}

void LZW_Dictionary::AddtoDict(uint1 character, int string_code)
{
	int firstsibling, nextsibling;
	if (0 > string_code) return;
	dict[next_code].suffix = character;
	dict[next_code].parent = string_code;
	dict[next_code].firstchild = -1;
	dict[next_code].nextsibling = -1;
	firstsibling = dict[string_code].firstchild;
	if (-1 < firstsibling) {	// the parent has child
		nextsibling = firstsibling;
		while (-1 < dict[nextsibling].nextsibling)
			nextsibling = dict[nextsibling].nextsibling;  //searching the last nextsibling
		dict[nextsibling].nextsibling = next_code;
	}
	else {// no child before, modify it to be the first
		dict[string_code].firstchild = next_code;
	}
	next_code++;  //important!!!!!
}

void LZW_Dictionary::PrintDict()
{
	//print dict after index of 255
	for (int i = 256; i < next_code; i++) {
		cout << i << ":  ";
		cout << dict[i].suffix << "  ";
		cout << dict[i].parent << "  ";
		cout << dict[i].firstchild << "  ";
		cout << dict[i].nextsibling << endl;
	}
}

int LZW_Dictionary::get_next_code()
{
	return next_code;
}

int LZW_Dictionary::DecodeString(int code, int last_code, int start)
{
	int count = 0;  //using d_stack to storage string
	if (code >= next_code) {  //case ABABA, the code is made by last code and it's fitst character
		count = 1;
		while (last_code >= 0) {
			start = 1;
			d_stack[count] = dict[last_code].suffix;
			last_code = dict[last_code].parent;
			count++;
		}
		d_stack[0] = d_stack[count - 1];
	}
	else {  //normal case
		while (code >= 0) {
			d_stack[count] = dict[code].suffix;
			code = dict[code].parent;
			count++;
		}
	}
	return count;
}

bool LZWencode(ifstream& file_in, BitFileOut& bit_out)
{
	LZW_Dictionary dictionary;
	int character(0), string_code(-1), index(0);
	uint4 file_length(0);

	if (!(file_in.is_open() && bit_out.is_open())) { 
		cerr << __func__ << "\t Can not open file!" << endl;
		return false; 
	}
	//get the length of file and output
	file_in.seekg(0, ios::end);
	file_length = file_in.tellg();
	file_in.seekg(0, 0);
	bit_out.BitsOutput(file_length, 4 * 8);
	//encode
	for (int current_len = 0; current_len < file_length; current_len++) {
		file_in.read(reinterpret_cast<char*>(&character), 1);
		index = dictionary.InDict(character, string_code);
		if (index >= 0) {
			string_code = index;
		}
		else {
			bit_out.BitsOutput((uint2)string_code, 16);
			if (dictionary.get_next_code() < MAX_size) {
				dictionary.AddtoDict(character, string_code);
			}
			string_code = character;
		}
	}
	bit_out.BitsOutput((uint2)string_code, 16);
	return true;
}

bool LZWdecode(ofstream& file_out, BitFileIn& bit_in)
{
	if (!(file_out.is_open() && bit_in.is_open())) {
		cerr << __func__ << "\t Can not open file!" << endl;
		return false;
	}
	LZW_Dictionary dic;
	bool is_end(false);
	int new_code(0), last_code(-1);
	int word_length(0);
	int character;
	int file_length = bit_in.BitsInput(4*8,is_end);
	if (is_end) { 
		cerr << __func__ << "\t the number of bits incorrect!" << endl;
		return false; 
	}
	//decode
	while (file_length > 0) {
		new_code = bit_in.BitsInput(16, is_end);
		if (is_end) {
			cerr << __func__ << "\t the number of bits incorrect!" << endl;
			return false;
		}
		word_length = dic.DecodeString(new_code, last_code);
		//add to dict
		if (dic.get_next_code() < MAX_size) {
			//Addtodict() will handle the case ABABA
			dic.AddtoDict(dic.d_stack[word_length - 1], last_code);
		}
		//out put bit stream to file
		while (0 < word_length) {
			word_length--;
			file_out.write(reinterpret_cast<const char*>(dic.d_stack + word_length), 1);
			file_length--;
		}
		last_code = new_code;
	}
	return true;
}

bitio.h

#pragma once
#ifndef  __bitio__
#define  __bitio__

#include <fstream>
using namespace std;

typedef unsigned char uint1;
typedef unsigned short uint2;
typedef unsigned int uint4;

class BitFileIn: public ifstream
{
public:
	BitFileIn(const char* path);
	~BitFileIn();
	uint1 BitInput(bool& flag);
	uint4 BitsInput(int count, bool& flag);

private:
	uint1 mask;
	uint1 rack;
};

class BitFileOut : public ofstream
{
public:
	BitFileOut(const char* path);
	~BitFileOut();
	void BitOutput(uint1 bit);
	void BitsOutput(uint4 code, uint4 count);
	void close();
private:
	uint1 mask;
	uint1 rack;
};

#endif // ! __bitio__

bitio.cpp

#include "bitio.h"
#include <iostream>
using namespace std;

BitFileIn::BitFileIn(const char* path): ifstream(path,ios::binary)
{
	mask = 0x80;
	rack = 0;
}

BitFileIn::~BitFileIn()
{
	ifstream::close();
}

uint1 BitFileIn::BitInput(bool& flag)
{
	//Using flag to mark reaching the end
	int value;
	if (mask == 0x80) {
		this->read(reinterpret_cast<char*>(&rack), 1);
		if (this->eof()) {  //if reach end
			cerr << __func__ << "\tRead after the end!" << endl;
			system("pause");
			flag = true;  //indicate reach the end
			return 0;
		}
	}
	value = mask & rack;
	mask >>= 1;
	if (mask == 0) { mask = 0x80; }
	return ((value)?1:0);
}

uint4 BitFileIn::BitsInput(int count, bool& flag)
{
	uint4 mask = 1L << (count - 1);
	uint4 value = 0L;
	while (mask != 0) {
		if (this->BitInput(flag)) { value |= mask; }
		mask >>= 1;
	}
	return value;
}

BitFileOut::BitFileOut(const char* path): ofstream(path, ios::binary)
{
	mask = 0x80;
	rack = 0;
}

BitFileOut::~BitFileOut()
{
	this->close();
}

void BitFileOut::BitOutput(uint1 bit)
{
	if (bit != 0) { rack |= mask; }
	mask >>= 1;
	if (mask == 0) {
		this->write(reinterpret_cast<const char*>(&rack), 1);
		//*(this) << rack;
		rack = 0;
		mask = 0x80;
	}
}

void BitFileOut::BitsOutput(uint4 code, uint4 count)
{
	uint4 mask = 1 << (count - 1);
	while (mask != 0) {
		this->BitOutput((code & mask) ? 1 : 0);
		mask >>= 1;
	}
}

void BitFileOut::close()
{
	//output remaining bits
	if (mask != 0x80) {
		this->write(reinterpret_cast<const char*>(&rack), 1);
		//*(this) << rack;
	}
	ofstream::close();
}

main.cpp

#define _CRT_SECURE_NO_WARNINGS
#include "bitio.h"
#include "lzw.h"
#include <iostream>
#include <string.h>
using namespace std;
#if 1
int main(int argc, char** argv)
{
	if (argc < 2) {
		cout << "usage: <filepath>" << endl;
		system("pause");
		exit(1);
	}

	ifstream file_in(argv[1], ios::binary);
	BitFileOut bit_out("./compressed.dat");
	if (!file_in.is_open()) { 
		cerr << "Can not open file!" << endl;
		system("pause");
		exit(1);
	}
	if (!bit_out.is_open()) {
		cerr << "Can not create compressed file!" << endl;
		system("pause");
		exit(1);
	}

	if (LZWencode(file_in, bit_out)) { cout << "compress finish!" << endl; }
	else { cout << "fail to compress" << endl; system("pause"); exit(1); }

	file_in.seekg(0, 0);
	file_in.seekg(0, ios::end);
	int file_length = file_in.tellg();
	cout << "The file length is:" << file_length << "  Bytes" << endl;

	file_in.close();
	bit_out.close();

	char h[64]("decode_");
	char* outname = strcat(h, argv[1]);

	ofstream file_out(outname,ios::binary);
	BitFileIn bit_in("./compressed.dat");
	if (!file_out.is_open()) {
		cerr << "Can not open decode file!" << endl;
		system("pause");
		exit(1);
	}
	if (!bit_in.is_open()) {
		cerr << "Can not create compressed file!" << endl;
		system("pause");
		exit(1);
	}
	if(LZWdecode(file_out, bit_in)){ cout << "compress finish!" << endl; }
	else{ cout << "fail to decode" << endl; system("pause"); exit(1); }

	bit_in.seekg(0, 0);
	bit_in.seekg(0, ios::end);
	int out_file_length = bit_in.tellg();
	cout << "The compressed file length is:" << out_file_length << "  Bytes" << endl;

	bit_in.close();
	file_out.close();
	system("pause");
	return 0;
}
#endif
本文内容由网友自发贡献，版权归原作者所有，本站不承担相应法律责任。如您发现有涉嫌抄袭侵权的内容，请联系:hwhale#tublm.com(使用前将#替换为@)

本科数据压缩课程

算法

字符串

c

数据压缩学习实验（四）LZW压缩算法的C++实现及其效率分析 的相关文章

  • WindowsError：[错误 126] 使用 ctypes 加载操作系统时

    python代码无法在Windows 7平台上运行 def libSO lib ctypes cdll LoadLibrary ConsoleApplication2 so lib cfoo2 1 3 当我尝试运行它时 得到来自python

  • 为什么这个 Web api 控制器不并发？

    我有一个 Web API 控制器 里面有以下方法 public string Tester Thread Sleep 2000 return OK 当我调用它 10 次 使用 Fiddler 时 我预计所有 10 次调用都会在大约 2 秒后

  • 将类对象放置在向量中？

    我注意到我可以将一个类放置在一个向量中 这是我的程序 我收到以下错误 out blackjack exe blackjack obj blackjack obj error LNK2019 unresolved external symbo

  • 转换 const void*

    我有一个函数返回一个const void 我想用它的信息作为char 我可以将它投射为 C 风格的罚款 char variable但是当我尝试使用reinterpret cast like reinterpret cast

  • 前向声明类型和“已声明为类类型的非类类型”

    我对以下代码有问题 template

  • extern 声明和函数定义都在同一文件中

    我只是浏览了一下gcc源文件 在gcc c 我发现了类似的东西 extern int main int char int main int argc char argv 现在我的疑问是extern是告诉编译器特定的函数不在这个文件中 但可以

  • 如何使用 Regex.Replace 从字符串中删除数字？

    我需要使用Regex Replace从字符串中删除所有数字和符号 输入示例 123 abcd33输出示例 abcd 请尝试以下操作 var output Regex Replace input d string Empty The d标识符

  • 在 VS 中运行时如何查看 C# 控制台程序的输出？

    我刚刚编写了一个名为 helloworld 的聪明程序 它是一个 C NET 4 5 控制台应用程序 在扭曲的嵌套逻辑迷宫深处 使用了 Console WriteLine 当我在命令行运行它时 它会运行并且我会看到输出 我可以执行其他命令并

  • 如何将AVFrame转换为glTexImage2D使用的纹理？

    如您所知 AVFrame 有 2 个属性 pFrame gt data pFrame gt linesize 当我从视频 sdcard test mp4 android平台 读取帧后 并将其转换为RGB AVFrame副 img conve

  • 在 .NET MAUI 中实现 TouchTracking

    我一直致力于将我们的应用程序从 Xamarin Forms 迁移到 NET MAUI 我们的应用程序几乎没有绘图功能 用户可以用手指进行绘图 我们用了TouchTrackingXamarin Forms 中的 nuget 包 但与 NET

  • 在 C 中使用枚举而不是 #defines 作为编译时常量是否合理？

    在 C 工作了一段时间后 我将回到 C 开发领域 我已经意识到 在不必要的时候应该避免使用宏 以便让编译器在编译时为您做更多的工作 因此 对于常量值 在 C 中我将使用静态 const 变量或 C 11 枚举类来实现良好的作用域 在 C 中

  • 将二变量 std::function 转换为单变量 std::function

    我有一个函数 它获取两个值 x 和 y 并返回结果 std function lt double double double gt mult double x double y return x y 现在我想得到一个常量 y 的单变量函数

  • 如何在 C# 中创建异步方法？

    我读过的每一篇博客文章都会告诉您如何在 C 中使用异步方法 但由于某些奇怪的原因 从未解释如何构建您自己的异步方法来使用 所以我现在有这段代码使用我的方法 private async void button1 Click object se

  • Oauth2中如何同时撤销RefreshToken和使AccessToken失效

    我正在使用 Owin Oauth2 授权和资源服务器相同 开发单页面应用程序 AngularJS Net MVC Json Rest API 的身份验证流程 我选择了 Bearer Token 路由而不是传统的 cookie session

  • 使动态创建的链接标签在 Winforms 中可点击

    我正在制作一个程序 允许用户单击由动态链接标签创建的公司名称 在我想知道如何做到这一点之前 我从未在 C 中使用过链接标签 可为特定用户生成的业务数量各不相同 因此每个用户的链接标签数量并不相同 然后我想捕获业务 ID 以进行 Json 调

  • C++：二叉树所有节点值的总和

    我正在准备面试 我被一个二叉树问题困住了 我们如何计算二叉树所有节点中存在的值的总和 优雅的递归解决方案 伪代码 def sum node if node NULL return 0 return node gt value sum nod

  • 了解 Lambda 表达式和委托 [关闭]

    Closed 这个问题需要多问focused help closed questions 目前不接受答案 我已经尝试解决这个问题很长一段时间了 阅读在线博客和文章 但到目前为止还没有成功 什么是代表 什么是 Lambda 表达式 两者的优点

  • 在 Win32 控制台应用程序中设置光标位置

    如何在 Win32 控制台应用程序中设置光标位置 最好 我想避免制作句柄并使用 Windows 控制台功能 我花了整个早上沿着那条黑暗的小巷跑 它产生的问题比它解决的问题还要多 我似乎记得当我在大学时使用 stdio 做这件事相对简单 但我

  • 没有“对 *this”功能的右值引用的解决方法

    我有一个围绕可移动对象的代理容器类 并希望代理能够隐式生成对底层对象的右值引用 但仅当代理本身被移动时 我相信我将能够按照提案 n2439 实施此行为 将移动语义扩展到 this http www open std org jtc1 sc2

  • 我可以使用 lambda 函数或 std::function 对象来代替函数指针吗？

    我有一个需要使用的库 它定义了以下内容 typedef void CallbackFunction const int i 并且有一个注册回调的函数 如下所示 void registerCallback CallbackFunction p

随机推荐

  • Spring@Autowired注解与自动装配

    1 配置文件的方法 我们编写spring 框架的代码时候 一直遵循是这样一个规则 所有在spring中注入的bean 都建议定义成私有的域变量 并且要配套写上 get 和 set方法 Boss 拥有 Office 和 Car 类型的两个属性

  • IDER代码检查工具

    随着业务的发展 系统会越来越庞大 原本简单稳定的功能 可能在不断迭代后复杂度上升 潜在的风险也随之暴露 导致最终服务不稳定 造成业务价值的损失 而为了减少这种情况 其中一种比较好的方式就是提高代码质量 比如通过代码审查 从而降低错误风险 但

  • Qt控件米白色主题风格，QSS控件样式，Qt风格，Qt控件源代码

    米白色主题控件风格 使用c 开发 原生控件主题风格 主题预览图 由www qt ui com设计开发完成 提供主题源代码 主题下载地址 http www qt ui com theme UIGTE001 主题预览图 产品官网 www qt

  • 【QT进阶】第五章 QT绘图之自定义控件--仪表盘绘制

    作者主页 凉开水白菜 作者简介 共同学习 互相监督 热于分享 多加讨论 一起进步 专栏目录 零基础学QT 文章导航篇 专栏资料 https pan baidu com s 192A28BTIYFHmixRcQwmaHw 提取码 qtqt 点

  • 2.6 矩阵的初等变换

    文章目录 初等变换 行 列 定理 等价 性质 初等方阵 初等方阵与初等变换的关系 三种初等方阵的行列式 逆矩阵 定理 初等矩阵的作用 定理 A可逆条件总结 初等变换法求逆矩阵 初等行变换法 只做行变换 参考 初等变换 行 列 下面是三种初等

  • （5）Qt中的日期和时间

    QDate 日期对象格式化 d 没有前导零的日子 1 to 31 dd 前导为0的日子 01 to 31 ddd 显示 缩写 周一 周二 周三 周四 周五 周六 周日 dddd 显示 完整 星期一 星期二 星期三 星期四 星期五 星期六 星

  • 快速转载他人CSDN博客到自己博客中

    1 右键页面 选择审查元素 2 进入HTML代码页面 选择article content 如何快速找到article content 以谷歌浏览器为例子 鼠标右击 选择检查 点击小箭头 并把鼠标移动到文章内容中 看到baidu pl 点击下

  • 使用 JMeter 完成常用的压力测试

    JMeter 完成常用的压力测试 文档选项 将此页作为电子邮件发送 拓展 Tomcat 应用 下载 IBM 开源 J2EE 应用服务器 WAS CE 新版本 V1 1 摘自 http www 360doc com showWeb 0 0 2

  • C++基础之四个默认函数(构造，析构，拷贝构造，赋值运算符重载)

    文章目录 一 构造函数 构造函数的默认值 赋值方法 二 析构函数 三 拷贝构造函数 四 赋值运算符重载函数 一 构造函数 类的构造函数是类的一种特殊的成员函数 它会在每次创建类的新对象时执行 构造函数的名称与类的名称是完全相同的 并且不会返

  • A State-of-the-Art Survey on Deep Learning Theory and Architectures论文翻译分析

    A State of the Art Survey on Deep Learning Theory and Architectures 摘要 近年来 深度学习在各种应用领域取得了巨大成功 机器学习这一新领域发展迅速 已应用于大多数传统应用领

  • （超详细、带图带源码）Nacos注册中心的搭建与测试

    前言 本系列是从头开始进行学习Nacos的相关知识 从相关概念到业务开发等等 本篇是第三篇 主要知道为什么需要注册中心 为什么选择Nacos作为注册中心和Nacos作为注册中心的快速搭建 入门篇 阿里Nacos系列 为什么要选择Nacos和

  • 密码学技术在区块链系统中的应用

    密码学技术是区块链数据核心技术 P2P网络协议 共识机制 密码学技术 账户与存储模型 中核心的技术点 区块链主要用到的密码算法有哈希算法和加密算法 加密又包括对称性加密和非对称性加密两个概念 区块链系统里面一般常用到的是非对称加密 本文首先

  • 02-neo4j的基本命令

    1 插入节点 插入一个Person类别的节点 且这个节点有一个属性name 属性值为Andres CREATE n Person name 梁川川 CREATE n Person name 谢静静 CREATE n Person name

  • MySql数据库基础--常用函数&视图

    常用函数 日期函数 获取当前日期 select NOW 获取指定日期的日部分 select day now 获取指定日期的月部分 SELECT MONTH NOW 获取指定日期的n年部分 SELECT YEAR NOW date forma

  • Mysql锁

    文章目录 1 概述 2 分类 3 全局锁 4 表级锁 5 行级锁 1 概述 锁是计算机协调多个进程或线程并发访问某一资源的机制 在数据库中 除传统的计算资源 CPU RAM I O 的争用以外 数据也是一种供许多用户共享的资源 如何保证数据

  • 班级学生成绩统计管理系统---（C语言简易版）

    include

  • ViewPager2滑动页面滑动到最后再次滑动跳转到新页面 When swipe to left at the last page, jump to new page

    代码如下 package com example hrminiapp import androidx appcompat app AppCompatActivity import androidx viewpager2 widget Vie

  • MatConvNet的简单介绍和手写识别运用

    1 MatConvNet的简介 MatConvNet是一个实现卷积神经网络 CNN 的MATLAB工具箱 用于计算机视觉应用 它简单 高效 并且可以运行和学习最先进的CNN 许多用于图像分类 分割 人脸识别和文本检测的预训练CNN都有提供

  • Java - JUC -常用的并发工具类

    Condition Condition是JUC里面多线程协调通信的工具类 可以让一些线程一起等待条件即 Condition 只有当满足条件时 线程才会被唤醒 类似于 wait notify 在Condition中也有类似的实现 public

  • 数据压缩学习实验（四）LZW压缩算法的C++实现及其效率分析

    实验目的 掌握词典编码的基本原理 阅读C语言实现的LZW算法并用C 按自己理解实现LZW解码器并分析编解码算法 以及LZW算法对不同文件的压缩效果 LZW算法原理 关于更具体的图解LZW编解码可以参考 超级简单的数据压缩算法 LZW算法 编

热门标签