C++ 实现二叉树

最新推荐文章于 2024-09-15 11:40:06 发布
最新推荐文章于 2024-09-15 11:40:06 发布
阅读量502 收藏 4
点赞数 5
文章标签： c++ 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_55303547/article/details/142031181
版权

使用C++编写一个类模板，实现二叉树的创建（通过前序序列和中序序列非递归地创建）、遍历（前序、中序、后序、层次遍历）、查找（根据值查找，二叉树中的值唯一）、删除、打印功能。

根据前序序列和中序序列非递归地创建二叉树

众所周知，若已知一个中序序列和其他三种遍历序列中的任意一个，就可以唯一确定一棵二叉树。已知一棵二叉树的前序序列和中序序列，如何非递归地创建二叉树呢？
假设有如下二叉树：
>
其前序序列为：1，2，4，5，3，6，7，8
其中序序列为： 4，2，5，1，3，7，6，8
可以看到，每个结点的左右子树在序列中都是连续的，比如根结点1的左子树在前序序列中是连续的2、4、5，在中序序列中是连续的4、2、5。并且前序序列中每一段的第一个即是子树根结点的值，所以可以用两个数组来表示这两个序列，通过根结点在中序数组中的下标确定左右子树的下标范围进而得知左右子树的长度，因为左右子树在前序数组中的表示是连续的（左子树后紧跟着右子树），所以左子树最后一个结点的下一个结点就是右子树的根结点。
设计如下结构体用于保存必要的信息（前序数组中的根结点下标、中序数组中的左右子树范围下标、指向当前结点的父结点的指针、表示当前结点是否为左孩子的布尔值）：

typedef struct data {
	size_t start{};//前序序列中的下一个子树根结点位置
	size_t start_in{};//中序序列中左右子树起始位置
	size_t end_in{};//中序序列中左右子树结束位置
	NODE* parent{};
	bool isLeft{ true };
} DATA;

使用一个队列保存每个结点对应的结构体DATA，当要创建一个结点时，读取队列头的结构体，从结构体中获取该结点的父结点，并将本结点设为父结点的左孩子或者右孩子，父结点总是先于子结点被创建。需要注意的是，根结点没有父结点，为了简化代码，可以为根结点创建一个临时的父结点，根结点作为其左孩子。过程如下：
在这里插入图片描述
代码实现如下：

//根据前序序列和中序序列创建二叉树
template<typename T>
inline typename BinaryTree<T>::NODE* BinaryTree<T>::create(const vector<T>& prev, const vector<T>& in){
if (m_num != 0) {
	throw std::exception("二叉树已经创建");
}
if (prev.empty() || in.empty()) {
	throw std::exception("空的数组");
}
if (prev.size() != in.size()) {
	throw std::exception("两个序列长度不一致");
}
typedef struct data {
	size_t start{};//前序序列中的下一个子树根结点位置
	size_t start_in{};//中序序列中左右子树起始位置
	size_t end_in{};//中序序列中左右子树结束位置
	NODE* parent{};
	bool isLeft{ true };
} DATA;
auto length{ prev.size() };
deque<DATA> d{};//队列
NODE* proot = new NODE();
proot->leftChild = nullptr;
d.push_back({ 0,0,length - 1,proot,true });//队列中第一个元素用于开始循环，是一个以根结点为左孩子的结点
size_t start{};//前序序列左右子树起始位置
size_t end{ length - 1 };//前序序列左右子树结束位置
size_t index{};//中序序列索引
while (!d.empty()) {
	auto start = d.front().start;
	auto start_in = d.front().start_in;
	auto end_in = d.front().end_in;
	auto parent = d.front().parent;
	auto isLeft = d.front().isLeft;
	d.pop_front();
	index = start_in;
	while ((prev[start] != in[index]) && (index <= end_in)) {
		index++;
	}
	if (index > end_in) {
		throw std::exception("错误的序列");
	}
	auto rootValue{ in[index] };//子树根结点值
	auto curNode = new NODE();
	curNode->value = rootValue;
	if (isLeft) {
		parent->leftChild = curNode;
		m_num++;
	}
	else {
		parent->rightChild = curNode;
		m_num++;
	}
	if (start_in == end_in) {
		continue;
	}
	if (index > start_in && index < end_in) {//既有左子树又有右子树
		d.push_back({ start + 1,start_in,index - 1,curNode,true });
		d.push_back({ start + 1 + (index - 1 - start_in + 1),index + 1,end_in,curNode,false });
	}
	if (index == start_in) {//只有右子树
		d.push_back({ start + 1,index + 1,end_in,curNode,false });
	}
	if (index == end_in) {//只有左子树
		d.push_back({ start + 1,start_in,index - 1,curNode,true });
	}
	//如果start_in等于end_in，则该位置的结点为叶结点
}
m_root = proot->leftChild;//获取根结点
return m_root;
}

BinaryTree.hpp

#pragma once
#include <memory>
#include <vector>
#include <deque>
#include <iostream>

using std::cout;
using std::endl;
using std::deque;
using std::vector;

template<typename T>
class BinaryTree {
public:
	BinaryTree();
	BinaryTree(const BinaryTree& src);
	BinaryTree(BinaryTree&& src)noexcept;
	BinaryTree& operator=(const BinaryTree& rhs);
	BinaryTree& operator=(BinaryTree&& rhs)noexcept;
	~BinaryTree();

public:
	using NODE = struct binaryTreeNode {
		struct binaryTreeNode* leftChild{};//左孩子
		struct binaryTreeNode* rightChild{};//右孩子
		T value{};//结点值
	};
	NODE* m_root{};//根结点
	size_t m_num{};//结点个数

public:
	std::unique_ptr<T[]> preOrder();//前序遍历
	std::unique_ptr<T[]> inOrder();//中序遍历
	std::unique_ptr<T[]> postOrder();//后序遍历
	std::unique_ptr<T[]> levelOrder();//层次遍历
	void print();//打印二叉树
	NODE* create(const vector<T>& prev, const vector<T>& in);//通过前序序列和中序序列创建二叉树
	NODE* find(const T& value);
	void erase(NODE* node);
};
//默认构造函数
template<typename T>
BinaryTree<T>::BinaryTree() {

}
//拷贝构造函数
template<typename T>
BinaryTree<T>::BinaryTree(const BinaryTree& src) :BinaryTree{} {
	m_num = src.m_num;
	deque<NODE*> d_src{};
	NODE** d{ new NODE * [m_num] };

	size_t head{};
	size_t rear{};
	d_src.push_back(src.m_root);
	d[0] = new NODE;
	d[0]->value = src.m_root->value;//复制根结点
	m_root = d[0];
	NODE* front{};
	while (!d_src.empty()) {
		front = d_src.front();
		d_src.pop_front();
		auto* left = front->leftChild;
		auto* right = front->rightChild;
		if (left) {
			d_src.push_back(left);
			NODE* node = new NODE;
			node->value = front->leftChild->value;//复制左子结点值
			d[head]->leftChild = node;
			d[++rear] = node;
		}
		if (right) {
			d_src.push_back(right);
			NODE* node = new NODE;
			node->value = front->rightChild->value;//复制右子结点值
			d[head]->rightChild = node;
			d[++rear] = node;
		}
		head++;
	}
	delete[] d;//释放指针数组
}
//移动构造函数
template<typename T>
BinaryTree<T>::BinaryTree(BinaryTree&& src)noexcept {
	m_root = src.m_root;
	m_num = src.m_num;
	src.m_root = nullptr;
	src.m_num = 0;
}
//拷贝赋值运算符
template<typename T>
BinaryTree<T>& BinaryTree<T>::operator=(const BinaryTree& rhs) {
	if (this == &rhs)return *this;//检查自我赋值
	if (m_num != 0) {
		deque<NODE*> d1{};
		d1.push_back(m_root);
		while (!d1.empty()) {
			if (d1.front()->leftChild) {
				d1.push_back(d1.front()->leftChild);
			}
			if (d1.front()->rightChild) {
				d1.push_back(d1.front()->rightChild);
			}
			delete d1.front();
			d1.pop_front();
		}//删除原来的结点
	}
	m_num = rhs.m_num;
	deque<NODE*> d_rhs{};
	NODE** d2{ new NODE * [m_num] };
	size_t head{};
	size_t rear{};
	d_rhs.push_back(rhs.m_root);
	d2[0] = new NODE;
	d2[0]->value = rhs.m_root->value;//复制根结点
	m_root = d2[0];
	NODE* front{};
	while (!d_rhs.empty()) {
		front = d_rhs.front();
		d_rhs.pop_front();
		auto* left = front->leftChild;
		auto* right = front->rightChild;
		if (left) {
			d_rhs.push_back(left);
			NODE* node = new NODE;
			node->value = front->leftChild->value;//复制左子结点值
			d2[head]->leftChild = node;
			d2[++rear] = node;
		}
		if (right) {
			d_rhs.push_back(right);
			NODE* node = new NODE;
			node->value = front->rightChild->value;//复制右子结点值
			d2[head]->rightChild = node;
			d2[++rear] = node;
		}
		head++;
	}
	delete[] d2;//释放指针数组
	return *this;
}
//移动赋值运算符
template<typename T>
BinaryTree<T>& BinaryTree<T>::operator=(BinaryTree&& rhs)noexcept {
	if (this == &rhs)return *this;
	if (m_num != 0) {
		deque<NODE*> d{};
		d.push_back(m_root);
		while (!d.empty()) {
			if (d.front()->leftChild) {
				d.push_back(d.front()->leftChild);
			}
			if (d.front()->rightChild) {
				d.push_back(d.front()->rightChild);
			}
			delete d.front();
			d.pop_front();
		}//删除原来的结点
	}
	m_num = rhs.m_num;
	m_root = rhs.m_root;
	rhs.m_num = 0;
	rhs.m_root = nullptr;
	return *this;
}
//析构函数
template<typename T>
inline BinaryTree<T>::~BinaryTree()
{
	if (m_num != 0) {
		deque<NODE*> d{};
		d.push_back(m_root);
		while (!d.empty()) {
			if (d.front()->leftChild) {
				d.push_back(d.front()->leftChild);
			}
			if (d.front()->rightChild) {
				d.push_back(d.front()->rightChild);
			}
			delete d.front();
			d.pop_front();
		}
		m_root = nullptr;
	}
}
//前序遍历
template<typename T>
inline std::unique_ptr<T[]> BinaryTree<T>::preOrder()
{
	std::unique_ptr<T[]> res{ new T[m_num] };
	vector<NODE*> v{};
	size_t count{};
	NODE* got{};
	auto p{ m_root };
	while (p || !v.empty()) {
		if (p) {
			res[count++] = p->value;
			v.push_back(p);
			p = p->leftChild;
		}
		else {
			p = v.back()->rightChild;
			v.pop_back();
		}
	}
	return res;
}
//中序遍历
template<typename T>
inline std::unique_ptr<T[]> BinaryTree<T>::inOrder()
{
	std::unique_ptr<T[]> res{ new T[m_num] };
	vector<NODE*> v{};
	size_t count{};
	NODE* got{};
	auto p{ m_root };
	while (p || !v.empty()) {
		if (p) {
			v.push_back(p);
			p = p->leftChild;
		}
		else {
			res[count++] = v.back()->value;
			p = v.back()->rightChild;
			v.pop_back();
		}
	}
	return res;
}
//后序遍历
template<typename T>
inline std::unique_ptr<T[]> BinaryTree<T>::postOrder()
{
	auto res{ std::make_unique<T[]>(m_num) };
	size_t count{};
	vector<NODE*> v{};
	NODE* got{};
	NODE* p{ m_root };
	while (!v.empty() || p) {
		if (p) {
			v.push_back(p);
			p = p->leftChild;
		}
		else {
			p = v.back();
			if (p->rightChild && p->rightChild != got) {
				p = p->rightChild;
			}
			else {
				res[count++] = v.back()->value;
				got = v.back();
				p = nullptr;
				v.pop_back();
			}
		}
	}
	return res;
}
//层次遍历
template<typename T>
inline std::unique_ptr<T[]> BinaryTree<T>::levelOrder()
{
	std::unique_ptr<T[]> res{ new T[m_num] };
	deque<NODE*> d{};
	d.push_back(m_root);
	size_t count{};
	NODE* front{};
	while (!d.empty()) {
		front = d.front();
		res[count++] = front->value;
		if (front->leftChild) {
			d.push_back(front->leftChild);
		}
		if (front->rightChild) {
			d.push_back(front->rightChild);
		}
		d.pop_front();
	}
	return res;
}

template<typename T>
inline void BinaryTree<T>::print()
{
	if (m_num == 0) {
		cout << "二叉树为空" << endl;
		return;
	}
	deque<NODE*> d{};
	d.push_back(m_root);
	auto* front = d.front();
	cout << "二叉树共有" << m_num << "个结点" << endl;
	while (!d.empty()) {
		front = d.front();
		if (front->leftChild && front->rightChild) {
			cout << front->value << " L: " << front->leftChild->value << " R: " << front->rightChild->value << "\n";
			d.push_back(front->leftChild);
			d.push_back(front->rightChild);
		}
		else if (front->leftChild) {
			cout << front->value << " L: " << front->leftChild->value << "\n";
			d.push_back(front->leftChild);
		}
		else if (front->rightChild) {
			cout << front->value << " R: " << front->rightChild->value << "\n";
			d.push_back(front->rightChild);
		}
		else {
			cout << front->value << " 是叶结点\n";
		}
		d.pop_front();
	}
	return;
}
//根据前序序列和中序序列创建二叉树
template<typename T>
inline typename BinaryTree<T>::NODE* BinaryTree<T>::create(const vector<T>& prev, const vector<T>& in){
	if (m_num != 0) {
		throw std::exception("二叉树已经创建");
	}
	if (prev.empty() || in.empty()) {
		throw std::exception("空的数组");
	}
	if (prev.size() != in.size()) {
		throw std::exception("两个序列长度不一致");
	}
	typedef struct data {
		size_t start{};//前序序列中的下一个子树根结点位置
		size_t start_in{};//中序序列中左右子树起始位置
		size_t end_in{};//中序序列中左右子树结束位置
		NODE* parent{};
		bool isLeft{ true };
	} DATA;
	auto length{ prev.size() };
	deque<DATA> d{};//队列
	NODE* proot = new NODE();
	proot->leftChild = nullptr;
	d.push_back({ 0,0,length - 1,proot,true });//队列中第一个元素用于开始循环，是一个以根结点为左孩子的结点
	size_t start{};//前序序列左右子树起始位置
	size_t end{ length - 1 };//前序序列左右子树结束位置
	size_t index{};//中序序列索引

	while (!d.empty()) {
		auto start = d.front().start;
		auto start_in = d.front().start_in;
		auto end_in = d.front().end_in;
		auto parent = d.front().parent;
		auto isLeft = d.front().isLeft;
		d.pop_front();
		index = start_in;
		while ((prev[start] != in[index]) && (index <= end_in)) {
			index++;
		}
		if (index > end_in) {
			throw std::exception("错误的序列");
		}
		auto rootValue{ in[index] };//子树根结点值
		auto curNode = new NODE();
		curNode->value = rootValue;
		if (isLeft) {
			parent->leftChild = curNode;
			m_num++;
		}
		else {
			parent->rightChild = curNode;
			m_num++;
		}
		if (start_in == end_in) {
			continue;
		}
		if (index > start_in && index < end_in) {//既有左子树又有右子树
			d.push_back({ start + 1,start_in,index - 1,curNode,true });
			d.push_back({ start + 1 + (index - 1 - start_in + 1),index + 1,end_in,curNode,false });
		}
		if (index == start_in) {//只有右子树
			d.push_back({ start + 1,index + 1,end_in,curNode,false });
		}
		if (index == end_in) {//只有左子树
			d.push_back({ start + 1,start_in,index - 1,curNode,true });
		}
		//如果start_in等于end_in，则该位置的结点为叶结点
	}
	m_root = proot->leftChild;//获取根结点
	return m_root;
}

template<typename T>
inline typename BinaryTree<T>::NODE* BinaryTree<T>::find(const T& value)
{
	deque<NODE*> d{ m_root };
	while (d.front()) {
		if (d.front()->value == value) {
			return d.front();
		}
		else {
			if (d.front()->leftChild) {
				d.push_back(d.front()->leftChild);
			}
			if (d.front()->rightChild) {
				d.push_back(d.front()->rightChild);
			}
		}
		d.pop_front();
	}
	return nullptr;
}

template<typename T>
inline void BinaryTree<T>::erase(NODE* node)
{
	deque<NODE*> D{};
	D.push_back(m_root);
	NODE* front_D{};
	NODE* front_d{};
	while (!D.empty()) {
		front_D = D.front();
		if ((front_D->leftChild == node) || (front_D->rightChild == node) || (front_D == node)){
			deque<NODE*> d{};
			d.push_back(node);
			while (!d.empty()) {
				front_d = d.front();
				if (front_d->leftChild) {
					d.push_back(front_d->leftChild);
				}
				if (front_d->rightChild) {
					d.push_back(front_d->rightChild);
				}
				delete front_d;
				m_num--;
				d.pop_front();
			}
			if (front_D->leftChild == node) {
				front_D->leftChild = nullptr;
			}
			if (front_D->rightChild == node) {
				front_D->rightChild = nullptr;
			}
			break;
		}
		if (front_D->leftChild) {
			D.push_back(front_D->leftChild);
		}
		if (front_D->rightChild) {
			D.push_back(front_D->rightChild);
		}
		D.pop_front();
	}
	return;
}

main.cpp

#include "BinaryTree.hpp"
#include <memory>
#include <iostream>
using std::cout;
using std::cin;
using std::endl;
using std::move;
using std::string;

int main()
{
    _CrtSetDbgFlag(_CRTDBG_ALLOC_MEM_DF | _CRTDBG_LEAK_CHECK_DF);

    vector<int> vprev1{ 1,2,4,6,11,5,8,9,3,7,10 };
    vector<int> vin1{ 6,11,4,2,8,5,9,1,3,7,10 };
    BinaryTree<int> bt{};
    try {
        bt.create(vprev1, vin1);
        auto bt1{ bt };
        bt1 = move(bt);
        cout << "后序遍历\n";
        auto res = bt1.postOrder();
        for (int i{}; i < 11; ++i) {
            cout << res[i] << " ";
        }
        cout << endl;
        bt1.print();
        auto p{ bt1.find(5) };
        bt1.erase(p);
        bt1.print();
    }
    catch (const std::exception& e) {
        cout << e.what() << endl;
    }
    return 0;
}

在这里插入图片描述

平面海螺
关注
根据二叉树前序遍历和中序遍历的结果输出后序遍历(java)
04-11
NULL 博文链接：https://128kj.iteye.com/blog/1692248
C++实现二叉树
qq_45285738的博客
03-10 1057
接下来，你将看到，输出先序、层序遍历结果等内容，如下：（注：中序后序，操作类似于前序遍历，没有实现）1.2 实现二叉树的访问 --- 先中后序访问、层序访问。1.3 计算树的深度、节点数、复制树。2.1 首先创建出一棵二叉树。1.1 实现二叉树的创建。
C++实现二叉树及相关操作
qq_60012598的博客
04-09 585
二叉树的定义：是一种树形结构，特点是每个节点最多有两棵子树并且有左右之分二叉树的五种形态：空树，只有一个根，一个根和一个左子树，一个根和一个右子树，根和左右子树二叉树的特性：1.第i层最多有2的（i-1）次方个节点2.深度为h的二叉树最多有2的（h-1）次方个节点3.对一个完全二叉树进行顺序编号，对于编号为i的结点，i=1，为根；i%2=0说明 有该结点的父节点有一个左子树，i%2>0说明有左右子树。
C++实现二叉树的非递归遍历
qq_41696018的博客
08-23 1748
在前面C++实现二叉树的递归遍历(详细步骤与代码实现)我们实现二叉树通过递归遍历实现了先序、中序与后续遍历，那么如何通过非递归遍历实现先序、中序与后续遍历呢？我们先看看非递归遍历规则。 还是同样的二叉树 1、首先将二叉树根节点A放入栈中，并将节点是否打印标签设为false。 2、再将节点A从栈中弹出，将其左右子树节点BF入栈，打印标签设为false，将A再次入栈，此时是否打印的标签设为true（注意这里三个节点入栈顺序与先序、中序与后续遍历方式有关,入栈顺序与遍历顺序正好相反，...
C++实现二叉树三种遍历方法
qq_40624616的博客
03-14 8395
文章目录前序遍历--递归中序遍历--递归后序遍历--递归 前序遍历–递归 文中的二叉树结构如下： struct TreeNode { int val; TreeNode* left; TreeNode* right; TreeNode() : val(0), left(nullptr), right(nullptr) {} TreeNode(int x) : val(x), left(nullptr), right(nullptr) {} TreeNode(int x, TreeNode* le
c++实现二叉树
weixin_42817333的博客
06-01 1250
c++数组实现二叉树
C++实现二叉树的中序遍历
persistence_Y的博客
10-20 1956
#include <iostream> #include <vector> #include <stack> using namespace std; //C++实现二叉树中序遍历 struct TreeNode{ int val; TreeNode * left; TreeNode * right; TreeNode(int x) : val...
c++实现二叉树并遍历
qq_43575504的博客
04-03 1060
Ⅰ 有且只有一个称为根的节点 Ⅱ 有若干个互不相交的子树，这些子树本身也是一棵树 节点、父节点、子节点、子孙、堂兄弟 深度：从根节点到最底层节点的层数，根节点是第一层 叶子节点：没有子节点的节点 非终端节点：非叶子节点 度：子节点的个数 Ⅰ 一般树木：任意一个节点的子节点个数不受限制 Ⅱ 二叉树：任意一个节点的子节点个数最多两个，且子节点位置不可更改 ① 一般二叉树
C++实现二叉树的创建和遍历
m0_62367990的博客
12-27 836
实现二叉树的创建和遍历：1、实现二叉树的创建，存储结构为二叉链表结点类型。2、创建后实现先序中序后序的遍历结果。
C++实现二叉树结构及其二叉树常用算法
weixin_45189666的博客
05-09 3596
文章目录头文件成员函数构造函数创建二叉树CreateBTNode输出二叉树DispBTree查找指定节点FindNode查找左、右孩子节点求树高BTreeHeight递归遍历非递归遍历前序遍历 头文件 使用node 定义节点，并重命名为BTNode。二叉树类 BTree中含有一个成员BTNode* head;存放二叉树的头节点。 typedef int ElemType; const int MaxSize = 20; //二叉树链式存储结构 typedef struct node { ElemT
c++实现二叉树，二叉树综合大礼包
10-28
"C++实现二叉树，二叉树综合大礼包" 本文将详细讲解C++实现二叉树的知识点，包括二叉树的构造、遍历、翻转和层序遍历等方面。 一、构造二叉树 构造二叉树可以通过前序遍历和中序遍历来实现。前序遍历的第一个元素...
c++实现二叉树的创建，遍历，添加，查找与删除
05-27
### C++实现二叉树的创建、遍历、添加、查找与删除资源描述 #### 资源概述 本资源详细介绍了如何使用C++实现二叉树的各种基本操作，包括创建、遍历、添加节点、查找节点和删除节点。这些操作是掌握二叉树数据结构...
基于C和C++实现二叉树编码的遗传算法实现数据拟合源码+实验报告+答辩PPT(课设作业).zip
05-06
基于C和C++实现二叉树编码的遗传算法实现数据拟合源码+实验报告+答辩PPT(课设作业).zip基于C和C++实现二叉树编码的遗传算法实现数据拟合源码+实验报告+答辩PPT(课设作业).zip基于C和C++实现二叉树编码的遗传算法实现...
基于C++实现二叉树的创建，遍历，添加，查找与删除
04-24
以上就是使用C++实现二叉树的基本操作。通过熟练掌握这些基础，你可以进一步探索二叉搜索树、平衡二叉树（如AVL树和红黑树）等高级主题，这些都为高效的数据处理提供了坚实的基础。实践这些概念有助于提高你的编程...
C++实现二叉树后序遍历
W96866的博客
04-26 2158
二叉树的后续遍历，是先遍历左子树，在遍历右子数，最后遍历根节点。 后续遍历的过程中我们需要借助栈来辅助 #include<iostream> #include<stack> //先构建一个二叉树结构体 struct BTreeNode{ int data; BTreeNode* lchild; BTreeNode* rchild; } void postOr...
C++ STL中sort函数
最新发布
weixin_43349440的博客
09-15 140
刷题中经常遇到，用于各种元素排序，可以自定义排序方式，vector、deque适用。详细讲解：https://zhuanlan.zhihu.com/p/36274119。，为避免QuickSort快排的递归调用带来过大的额外负荷，就改用。一旦分段后的数据量小于某个门槛。STL的sort算法，
C++与QML的数据交互
qq_50679120的博客
09-11 484
这里没什么好说的，在C++中组合好json后，通过信号发送到qml中，qml中是可以解析json的。通过Q_PROPERTY属性，可以轻松地在QML中读取和修改数据，并将其更新到C++中，先创建一个类。在QML接收，直接通过data.can_id这样的形式去访问结构体中的元素。这两个也没什么好说的，在C++中直接发送信号就好了，在C++中声明并注册一个结构体。然后发送信号到QML中。
C和指针：标准函数库
暮色年华的博客
09-11 668
longjmp 函数:一旦在程序的其他部分遇到了 longjmp 调用，并且传入了之前 setjmp 初始化的 jmp_buf 数组以及一个非零值作为跳转值，那么程序的控制就会立即跳回到与那个 jmp_buf 关联的 setjmp 处。setjmp 函数：一个函数中调用 setjmp 并传递一个类型为 jmp_buf 的数组作为参数时，setjmp 将会保存当前程序执行环境的一个快照（包括处理器寄存器和程序计数器等状态信息）到这个 jmp_buf 数组中。如果在某个低层的函数中检测到一个错误，你可以立。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

平面海螺

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

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

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

打赏作者

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

抵扣说明：

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

余额充值