【ONE·C++ || 异常】

news2024/11/15 22:24:46

总言

  主要介绍异常。

文章目录

  • 总言
  • 1、C++异常
    • 1.1、C语言传统的处理错误的方式
    • 1.2、异常概念
    • 1.3、异常的基本用法
      • 1.3.1、异常的抛出和捕获
        • 1.3.1.1、异常的抛出和匹配原则
        • 1.3.1.2、 在函数调用链中异常栈展开匹配原则
      • 1.3.2、异常的重新抛出
        • 1.3.2.1、演示一
        • 1.3.2.2、演示二
      • 1.3.3、异常安全
      • 1.3.4、异常规范
  • 2、 自定义异常体系
    • 2.1、基本说明
    • 2.2、相关演示
  • 3、标准库异常体系
  • 4、异常的优缺点
    • 4.1、优点
    • 4.2、缺点

  
  
  
  

  
  
  
  

1、C++异常

1.1、C语言传统的处理错误的方式

  1）、传统的错误处理机制：
  1. 终止程序，如assert。缺陷：用户难以接受。如发生内存错误，除0错误时就会终止程序。
  2. 返回错误码。缺陷：需要自己去查找对应的错误。如系统的很多库的接口函数都是通过把错误码放到errno中，表示错误。

  PS：实际中C语言基本都是使用返回错误码的方式处理错误，部分情况下使用终止程序处理非常严重的错误。
  
  
  

1.2、异常概念

  1）、基本介绍
  说明：
  ①异常是一种处理错误的方式，当一个函数发现自己无法处理的错误时就可以抛出异常，让函数的直接或间接的调用者处理这个错误。
  ②如果有一个块抛出一个异常，捕获异常的方法会使用 try 和 catch 关键字。try 块中放置可能抛出异常的代码，try 块中的代码被称为保护代码。

try
{
	// 保护的标识代码
}
catch (ExceptionName e1)
{
	// catch 块
}
catch (ExceptionName e2)
{
	// catch 块
}
catch (ExceptionName eN)
{
	// catch 块
}

  throw: 当问题出现时，程序会 “抛出” 一个异常，通过使用 throw 关键字来完成的。
  catch: 在想要处理问题的地方，通过异常处理程序捕获异常。catch 关键字用于捕获异常，可以有多个catch进行捕获。
  try: try 块中的代码标识将被激活的特定异常，它后面通常跟着一个或多个 catch 块。
  
  PS：相比于C语言，C++的异常是通过对象(ExceptionName)接收的，根据之前所学，一个对象内可存储的数据信息多种多样，如此丰富了错误信息。
  
  
  
  2）、基础演示
  相关代码如下：

double Division(int a, int b)
{
    // 当b == 0时抛出异常
    if (b == 0)
        throw "Division by zero condition!";
    else
        return ((double)a / (double)b);
}

void Func()
{
    //int a = 2, b = 3;
    int a = 2, b = 0;
    cout << "a: " << a << ",  b: " << b << endl;
    cout << Division(a, b) << endl;
}

int main()
{
    try {
        Func();
    }
    catch (const char* errmsg)
    {
        cout << errmsg << endl;
    }
    catch (...) {
        cout << "unkown exception" << endl;
    }
    return 0;
}

在这里插入图片描述
  
  
  
  
  

1.3、异常的基本用法

1.3.1、异常的抛出和捕获

1.3.1.1、异常的抛出和匹配原则

  1. 异常是通过抛出对象而引发的，该对象的类型决定了应该激活哪个catch的处理代码。
  演示如下：这里有两个catch，但上述throw "Division by zero condition!"相对匹配的类型是char*的对象。

在这里插入图片描述

double Division(int a, int b)
{
    // 当b == 0时抛出异常
    if (b == 0)
        //throw 123;
        throw "Division by zero condition!";
    else
        return ((double)a / (double)b);
}

void Func()
{
    //int a = 2, b = 3;
    int a = 2, b = 0;
    cout << "a: " << a << ",  b: " << b << endl;
    cout << Division(a, b) << endl;
}

int main()
{
    try {
        Func();
    }
    catch (const int errid)
    {
        cout << "catch (const int errid)" << endl;//用于验证

        cout << errid << endl;
    }
    catch (const char* errmsg)
    {
        cout << "const char* errmsg" << endl;//用于验证

        cout << errmsg << endl;
    }
    catch (...) {
        cout << "unkown exception" << endl;
    }
    return 0;
}

  
  
  
  
  2. 被选中的处理代码是调用链中与该对象类型匹配且离抛出异常位置最近的调用链中那一个。
在这里插入图片描述

double Division(int a, int b)
{
    // 当b == 0时抛出异常
    if (b == 0)
        throw 123;
        //throw "Division by zero condition!";
    else
        return ((double)a / (double)b);
}

void Func()
{
    try {
        //int a = 2, b = 3;
        int a = 2, b = 0;
        cout << "a: " << a << ",  b: " << b << endl;
        cout << Division(a, b) << endl;
    }
    catch (const char* errmsg)
    {
        cout << "Func() ------ const char* errmsg" << endl;//用于验证

        cout << errmsg << endl;
    }
}

int main()
{
    try {
        Func();
    }
    catch (const int errid)
    {
        cout << "main() ------ catch (const int errid)" << endl;//用于验证

        cout << errid << endl;
    }
    catch (...) {
        cout << "unkown exception" << endl;
    }
    return 0;
}

  
  
  
  

  PS：异常必须被捕获，不能存在没有匹配的异常类型的情况（会报错/终止程序，但这样子的程序行为是过于“大惊小怪的”。例如，①使用异常处理，本意是出错后弹出个对话框，用以错误警告，但该程序其它功能仍旧能正常执行，②若因没有匹配类型而直接把程序终止掉，这是我们不期望的行为方式。）

  为了防止出现此类情况，引入catch(...)：

  3. catch(...)可以捕获任意类型的异常，只是不知道该异常原因具体是什么。（只有在其它类型的捕获异常都匹配不上时，才用...捕获，表示未知异常。）
在这里插入图片描述

  
  
  
  

  4. 虽然在throw处我们可以自定义填写内容，但一般情况都是抛一个异常对象。写法如下：

class Exception//用于返回异常的对象
{
public:
    Exception(const string& errmsg, int id)
        :_errmsg(errmsg)
        ,_errid(id)
    {}

    int GetErrid()const
    {
        return _errid;
    }

    string GetErrmsg()const
    {
        return _errmsg;
    }

protected:
    string _errmsg;//错误信息
    int _errid;//标识id
};


double Division(int a, int b)
{
    // 当b == 0时抛出异常
    if (b == 0)
    {
        Exception e("除零错误!", 1);
        throw e;
    }
    else
        return ((double)a / (double)b);
}

void Func()
{
        //int a = 2, b = 3;
        int a = 2, b = 0;
        cout << "a: " << a << ",  b: " << b << endl;
        cout << Division(a, b) << endl;
}

int main()
{
    try {
        Func();
    }
    catch (const Exception& e)
    {
        cout << e.GetErrid() << "---" << e.GetErrmsg() << endl;
    }
    catch (...) {
        cout << "未知异常！！！" << endl;
    }
    return 0;
}

  PS：抛出异常对象后，会生成一个异常对象的拷贝，因为抛出的异常对象可能是一个临时对象，所以会生成一个拷贝对象，这个拷贝的临时对象会在被catch以后销毁。（这里的处理类似于函数的传值返回）
在这里插入图片描述

  
  
  
  
  5. 实际中抛出和捕获的匹配原则有个例外，并不都是类型完全匹配，可以抛出的派生类对象，使用基类捕获。
  
  PS：此处相关演示代码见下述小节2：自定义异常体系。
  
  
  
  
  

1.3.1.2、 在函数调用链中异常栈展开匹配原则

  根据上述异常的使用，当项目中存在多个函数调用时，异常的匹配规则如下：
  1. 首先检查throw本身是否在try块内部，如果在，则查找匹配的catch语句。若有匹配的，则调到catch的地方进行处理。
  2. 没有匹配的catch，则退出当前函数栈，继续在调用函数的栈中进行查找匹配的catch。
  3. 如果到达main函数的栈，依旧没有匹配的，则终止程序。 上述这个沿着调用链查找匹配的catch子句的过程称为栈展开。（实际中都会在最后加一个catch(...)捕获任意类型的异常，否则当有异常没捕获，程序就会直接终止。）
  4. 找到匹配的catch子句并处理以后，会继续沿着catch子句后面继续执行。
在这里插入图片描述

  
  
  
  
  

1.3.2、异常的重新抛出

  在一些场景中，有可能单个的catch不能完全处理一个异常，在进行一些校正处理以后，希望再交给更外层的调用链函数来处理，catch则可以通过重新抛出将异常传递给更上层的函数进行处理。
  
  
  

1.3.2.1、演示一

  以下述小节2中，自定义异常体系的代码为例。假设在 HttpServer中，我们要求当异常为“网络错误”时，要先连续请求三次，若都失败才将异常抛出。


// 服务器开发中通常使用的异常继承体系
class Exception//基类：异常对象
{
public:
	Exception(const string& errmsg, int id)
		:_errmsg(errmsg)
		, _id(id)
	{}
	virtual string what() const
	{
		return _errmsg;
	}
	int Geterrid()const
	{
		return _id;
	}
protected:
	string _errmsg;//错误信息
	int _id;//错误码
};

class HttpServerException : public Exception//异常对象：表示由协议产生的异常，继承了基类 Exception
{
public:
	HttpServerException(const string& errmsg, int id, const string& type)
		:Exception(errmsg, id)//注意这里初始化基类方式：详细看继承和多态章节
		, _type(type)
	{}
	virtual string what() const
	{
		string str = "HttpServerException:";
		str += _type;
		str += ":";
		str += _errmsg;
		return str;
	}
private:
	const string _type;
};

void SendMsg(const string & str)
{
	srand(time(0));
	if (rand() % 2 == 0)
	{
		throw HttpServerException("当前网络错误", 1, "get");
	}
	else if (rand() % 5 == 0)
	{
		throw HttpServerException("当前权限不足", 2, "post");
	}
	cout << "本次请求成功:" << str << endl;
}



void HttpServer()
{
	int count = 3;//用于表示请求次数
	string str = "客户端发送了一个请求.";

	while (1)
	{
		Sleep(1000);
		try {
			SendMsg(str);
		}
		catch (const Exception& e)
		{
			if (e.Geterrid() == 1 && count)
			{
				count--;
				cout << "count:" << count << endl;//方便测试观察
				continue;//继续while循环，再次try
			}
			else
			{
				throw e;//将异常抛出到上一层
			}
		}
	}

}


int main()
{
	while (1)
	{
		cout << "------------------------" << endl;//用以区分每一回合：方便测试观察

		try {
			HttpServer();//服务端层层调用
		}
		catch (const Exception& e) // Exception是基类对象。尽管上述通过继承设置了不同的异常体系，但这里直接捕获父类对象就可以。
		{
			// 多态
			cout << e.what() << endl;
		}
		catch (...)
		{
			cout << "Unkown Exception" << endl;
		}
	}
	return 0;
}

  演示结果如下：
在这里插入图片描述

  
  
  

1.3.2.2、演示二

  除了上述情况，还有以下这类情景：

double Division(int a, int b)
{
	// 当b == 0时抛出异常
	if (b == 0)
	{
		throw "除零错误!";
	}
	return (double)a / (double)b;
}
void Func()
{

	int* array = new int[10];//new：在堆区开辟空间
	try {
		int a = 2, b = 0;
		cout << Division(a, b) << endl;
	}//需要在当前try块内部进行异常捕获
	catch (...)//因为throw直接抛出到main的栈中，这里堆区开辟的空间没有得到释放，会造成内存泄漏
	{
		cout << "delete []" << array << endl;//但这里捕获只是为了释放堆区空间
		delete[] array;
		throw;//还需要将异常重新抛出，交给外部做后续处理。
	}
	// ...
	cout << "delete []" << array << endl;
	delete[] array;
}
int main()
{
	try
	{
		Func();
	}
	catch (const char* errmsg)
	{
		cout << errmsg << endl;
	}
	return 0;
}

  演示结果如下：
在这里插入图片描述
  
  
  
  

1.3.3、异常安全

  1、构造函数完成对象的构造和初始化，最好不要在构造函数中抛出异常，否则可能导致对象不完整或没有完全初始化。
  2、析构函数主要完成资源的清理，最好不要在析构函数内抛出异常，否则可能导致资源泄漏(内存泄漏、句柄未关闭等)

  3、C++中异常经常会导致资源泄漏的问题，比如在new和delete中抛出了异常，导致内存泄漏，在lock和unlock之间抛出了异常导致死锁，C++经常使用RAII来解决以上问题，关于RAII在智能指针中讲解。
在这里插入图片描述
  
  
  
  

1.3.4、异常规范

  1. 异常规格说明的目的是为了让函数使用者知道该函数可能抛出的异常有哪些。 可以在函数的后面接throw(类型)，列出这个函数可能抛掷的所有异常类型。

// 这里表示这个函数会抛出A/B/C/D中的某种类型的异常
void fun() throw(A，B，C，D);
// 这里表示这个函数只会抛出bad_alloc的异常
void* operator new (std::size_t size) throw (std::bad_alloc);

  2. 函数的后面接throw()，表示函数不抛异常。

// 这里表示这个函数不会抛出异常
void* operator delete (std::size_t size, void* ptr) throw();
// C++11 中新增的noexcept，表示不会抛异常
thread() noexcept;
thread (thread&& x) noexcept;

  3. 若无异常接口声明，则此函数可以抛掷任何类型的异常。
  
  注意事项：异常所提供的规范，只是期望能按照此规则执行，但不代表强制性行为。实际大多时候，C++中都会使用自定义异常体系，以下将进行讲解说明。
  
  
  
  
  

2、 自定义异常体系

2.1、基本说明

  说明：实际使用中，很多时候会自定义自己的异常体系，进行规范的异常管理。通常，抛出的都是继承的派生类对象，使用一个基类进行捕获。
在这里插入图片描述
  
  
  

2.2、相关演示

  相关代码如下：

// 服务器开发中通常使用的异常继承体系
class Exception//基类：异常对象
{
public:
	Exception(const string& errmsg, int id)
		:_errmsg(errmsg)
		, _id(id)
	{}
	virtual string what() const
	{
		return _errmsg;
	}
	int Geterrid()const
	{
		return _id;
	}
protected:
	string _errmsg;//错误信息
	int _id;//错误码
};

class SqlException : public Exception //异常对象一：表示由SQL产生的异常，继承了基类 Exception
{
public:
	SqlException(const string& errmsg, int id, const string& sql)
		:Exception(errmsg, id)
		, _sql(sql)
	{}

	virtual string what() const
	{
		string str = "SqlException:";
		str += _errmsg;
		str += "->";
		str += _sql;
		return str;
	}
private:
	const string _sql;
};

class CacheException : public Exception//异常对象二：表示由缓存产生的异常，继承了基类 Exception
{
public:
	CacheException(const string& errmsg, int id)
		:Exception(errmsg, id)
	{}
	virtual string what() const
	{
		string str = "CacheException:";
		str += _errmsg;
		return str;
	}
};

class HttpServerException : public Exception//异常对象三：表示由协议产生的异常，继承了基类 Exception
{
public:
	HttpServerException(const string& errmsg, int id, const string& type)
		:Exception(errmsg, id)
		, _type(type)
	{}
	virtual string what() const
	{
		string str = "HttpServerException:";
		str += _type;
		str += ":";
		str += _errmsg;
		return str;
	}
private:
	const string _type;
};

void SQLMgr()
{
	srand(time(0));
	if (rand() % 7 == 0)
	{
		throw SqlException("权限不足", 5, "select * from name = 'SQL'");
	}
	//throw "xxxxxx";
	cout << "本次请求成功" << endl;
}

void CacheMgr()
{
	srand(time(0));
	if (rand() % 5 == 0)
	{
		throw CacheException("权限不足", 3);
	}
	else if (rand() % 6 == 0)
	{
		throw CacheException("数据不存在", 4);
	}
	SQLMgr();
}


void HttpServer()
{
	// ...
	srand(time(0));
	if (rand() % 3 == 0)
	{
		throw HttpServerException("请求资源不存在", 1, "get");
	}
	else if (rand() % 4 == 0)
	{
		throw HttpServerException("权限不足", 2, "post");
	}
	CacheMgr();
}


int main()
{
	while (1)
	{
		Sleep(1000);
		try {
			HttpServer();//服务端层层调用
		}
		catch (const Exception& e) // Exception是基类对象。尽管上述通过继承设置了不同的异常体系，但这里直接捕获父类对象就可以。
		{
			// 多态
			cout << e.what() << endl;
		}
		catch (...)
		{
			cout << "Unkown Exception" << endl;
		}
	}
	return 0;
}

在这里插入图片描述
  
  
  
  
  

3、标准库异常体系

  相关链接：std::exception
  C++ 提供了一系列标准的异常，定义在 中，我们可以在程序中使用这些标准的异常。它们是以父子类层次结构组织起来的。（若有需要可查阅文档学习了解）

在这里插入图片描述

  
  

4、异常的优缺点

4.1、优点

  1、相比错误码的方式，异常对象可以清晰准确的展示出错误的各种信息，甚至可以包含堆栈调用的信息，这样可以帮助更好的定位程序的bug。
  2、传统方式中，返回错误码有一个很大的问题：在函数调用链中，深层的函数返回错误时，需要层层返回，才能在最外层拿到错误。（而若是异常体系，只需要抛出异常，会直接跳到相应catch捕获的地方，直接处理错误）
  3、 很多的第三方库都包含异常，比如boost、gtest、gmock等等常用的库，那么我们使用这些库时也需要使用到异常。
  4、部分函数使用异常更好处理，比如构造函数没有返回值，不方便使用错误码方式处理。比如T& operator(const size_t pos)这样的函数，如果pos越界了只能使用异常或者终止程序处理，没办法通过返回值表示错误。
  
  
  
  

4.2、缺点

  1、异常会导致程序的执行流乱跳，并且非常的混乱，并且是运行时出错抛异常就会乱跳。这会导致我们跟踪调试时以及分析程序时，比较困难。
  2、 异常会有一些性能的开销。当然在现代硬件速度很快的情况下，这个影响基本忽略不计。
  3、C++没有垃圾回收机制，资源需要自己管理。有了异常非常容易导致内存泄漏、死锁等异常安全问题。这个需要使用RAII来处理资源的管理问题。学习成本较高。
  4、C++标准库的异常体系定义得不完善，导致大家各自定义各自的异常体系，造成混乱。
  5、异常尽量规范使用，否则后果不堪设想，随意抛异常，外层捕获的用户苦不堪言。所以异常规范有两点：①抛出异常类型都继承自一个基类。②函数是否抛异常、抛什么异常，都使用 func（） throw();的方式规范化。
  
  
  
  
  
  
  

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/1074492.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

滑动窗口算法技巧

滑动窗口算法技巧

大家好&#xff0c;我是 方圆。在我刷了一些滑动窗口相关的题目之后&#xff0c;发现很有技巧性&#xff0c;只要掌握了解题思路&#xff0c;就会很简单&#xff0c;所以我决定用这篇帖子记录一下&#xff0c;也帮助同样在刷滑动窗口相关题目的同学。 使用滑动窗口解决的问题一…
阅读更多...
PADS规则设置

PADS规则设置

一&#xff0e;设置类规则(DRC检测规则) 默认所有类规则设置网络属性分类设置 网络属性附着颜色 选择电源类在DDR中设置非常实用 创建组合 方便模块整旋转移动 二,元件组合 选择组合 旋转组合 CtrlR旋转90&#xff1b;双击旋转任意角度 拆开组合(还独立元件操作) 三,设置过孔…
阅读更多...
【java学习】多维数组（10）

【java学习】多维数组（10）

文章目录 1. 二维数组 1. 二维数组 二维数组[][]&#xff1a;数组中的数组 格式1&#xff08;动态初始化&#xff09;&#xff1a;int[][] arr new int[3][2]; 解释说明&#xff1a; 定义了名称为arr的二维数组二维数组中有3个一维数组每个一维数组中有2个元素一维数组的名称…
阅读更多...
教资面试多烂才不合格 教师资格证面试难度分析

教资面试多烂才不合格 教师资格证面试难度分析

教资面试是否合格&#xff0c;主要取决于考生的表现是否符合教师职业要求和教育教学能力。以下是一些可能导致教资面试不合格的表现&#xff1a; 对教育事业缺乏热情&#xff0c;对所教授的学科不感兴趣&#xff0c;或者对教育工作没有正确的认知。 对学生的关注不足&#xf…
阅读更多...
C++学习day3

C++学习day3

目录 作业&#xff1a; 1> 思维导图 2>设计一个Per类&#xff0c;类中包含私有成员:姓名、年龄、指针成员身高、体重&#xff0c;再设计一个Stu类&#xff0c;类中包含私有成员:成绩、Per类对象p1&#xff0c;设计这两个类的构造函数、析构函数和拷贝构造函数。 效果图…
阅读更多...
【ICer的脚本练习】shell的三剑客：grep/sed/awk

【ICer的脚本练习】shell的三剑客：grep/sed/awk

系列的目录说明请见：ICer的脚本练习专栏介绍与全流程目录_尼德兰的喵的博客-CSDN博客 前言 大大小小的脚本我们写了几个了，在上一篇我们借助bashrc简单了解了bash语言的一些语法和组织规则。这一篇呢我们还是回到shell简单看下三个常用命令，毕竟脚本也可以视为复杂的命令尤…
阅读更多...
c++运算符

c++运算符

文章目录 运算符位运算符类型转换 运算符 #include<iostream> using namespace std;int main() {// 算术运算符cout << "1 2 " << 1 2 << endl; cout << "1 2 - 3 * 4 " << 1 2 - 3 * 4 << endl;short a…
阅读更多...
mfoc-hardnested在visual studio2022编译

mfoc-hardnested在visual studio2022编译

1、点击mfoc-hardnested.sln 2、没有clang LLVM (clang-cl) (未安装) 打开installer 点击修改: 单个组件中搜索clang &#xff0c;安装即可 3、编译 4、main函数 5、mfoc-hardnested.exe使用
阅读更多...
v-on事件处理指令；简写@事件名

v-on事件处理指令；简写@事件名

一、v-on 给元素&#xff08;标签&#xff09;绑定事件监听器 oninput、onclick、onchange、onblur等 1、 完整方式v-on:事件名“函数/方法” 2、简写方式事件名“函数/方法”&#xff0c;注意符号不能加冒号“&#xff1a;” input /click/change/blur ..... 代码如下&#xf…
阅读更多...
为什么不建议使用SELECT * ？

为什么不建议使用SELECT * ？

“不要使用SELECT ”几乎已经成为数据库使用的一条金科玉律&#xff0c;就连很多公司也明确表示不得使用作为查询的字段列表&#xff0c;更是让这条规则拥有了权威的加持。 为什么不建议直接使用SELECT *&#xff1f;我们总得搞清楚这其中的原因吧&#xff0c;不要别人说不建议…
阅读更多...
vue3 组件v-model绑定props里的值，修改组件的值要触发回调

vue3 组件v-model绑定props里的值，修改组件的值要触发回调

很早之前就写了&#xff0c;一直没写篇博客记录下 <select v-model"typeVal" />const emit defineEmits([update:type]); const props defineProps({type: { type: String, default: }, });const typeVal computed({get() {return props.type;},set(value…
阅读更多...
Flutter：open_file打开本地文件报错问题

Flutter：open_file打开本地文件报错问题

相关插件及版本&#xff1a; open_file: ^3.2.1 问题&#xff1a; 项目中一直用的这个插件&#xff0c;突然发现在安卓高版本不能正常使用&#xff0c;报权限问题permissionDenied&#xff0c;断点调试提示相关权限是MANAGE_EXTERNAL_STORAGE&#xff0c;申请权限之后还是不行&…
阅读更多...
PDF有限制不能复制怎么办？

PDF有限制不能复制怎么办？

大家现在接触PDF文件越来越多&#xff0c;有的时候在网上下载的PDF文件打开之后&#xff0c;发现选中文字之后无法复制。甚至其他功能也都无法使用&#xff0c;这是怎么回事&#xff1f;该怎么办&#xff1f; 当我们发现文件打开之后&#xff0c;编辑功能无法使用&#xff0c;很…
阅读更多...
探索视觉系统工作原理，聚焦机器人应用“新视界”

探索视觉系统工作原理，聚焦机器人应用“新视界”

原创 | 文 BFT机器人 01 视觉系统&#xff1a;机器人的“眼睛” 视觉系统是一个非常复杂的系统&#xff0c;包括照明系统、镜头、摄像系统和图像处理系统。机器视觉系统主要由三部分组成&#xff1a;图像的获取、图像的处理和分析、输出或显示。 从功能上看&#xff0c;典型的…
阅读更多...
Allegro批量剪断走线操作

Allegro批量剪断走线操作

在用Allegro设计 PCB过程中，有时候由于原理图改动，导致布局的改动。这就会导致走完的线要重新走，对于差分对因为前半部分的走线是不用重新走的。那就可以使用剪断后面部分的线，然后删除，提高走线的效率。那如何批量剪断走线呢？ （1）选择菜单Manufacture→Drafting→Dele…
阅读更多...
ROS2学习(六)Bag回放使用plotjugger

ROS2学习(六)Bag回放使用plotjugger

Plotjugger Plotjugger是一个类似rqt_plot的可视化工具&#xff0c;但PlotJuggler拥有更强大和好用的功能。你可以导入文本文件让它显示文本文件中的数据&#xff0c;可以导入csv等各种格式的文件&#xff0c;支持画出数据曲线2. Bag回放 使用Plotjugger 可以导入ros的bag包…
阅读更多...
docker pull 拉取镜像报错

docker pull 拉取镜像报错

报错信息&#xff1a;Error response from daemon: toomanyrequests: You have reached your pull rate limit. You may increase the limit by authenticating and upgrading: https://www.docker.com/increase-rate-limit 简单理解就是拉取镜像失败&#xff0c;外部原因&…
阅读更多...
HDLbits: Lfsr5

HDLbits: Lfsr5

我的错误写法&#xff0c;半成品&#xff0c;完全错误&#xff1a; module top_module(input clk,input reset, // Active-high synchronous reset to 5h1output [4:0] q ); dff dff_1(clk, 0 ^ q[0],q[4]);dff dff_2(clk, q[4] ,q[3]);dff dff_3(clk, q[3] ^ q[0] ,q[2]);…
阅读更多...
2023年中国棋牌桌市场规模及行业前景：更具创意和功能是未来趋势[图]

2023年中国棋牌桌市场规模及行业前景：更具创意和功能是未来趋势[图]

棋牌桌行业是指涉及棋牌类游戏的桌面制造、销售和相关服务的产业&#xff0c;它包括生产和销售各种类型的棋牌桌&#xff0c;如象棋桌、扑克桌、麻将桌等&#xff0c;以及提供与这些游戏相关的配件和设备。 棋牌桌行业分类 资料来源&#xff1a;共研产业咨询&#xff08;共研网…
阅读更多...
Android多线程学习：多线程同步

Android多线程学习：多线程同步

一、多线程 多线程就是指一个进程中同时有多个线程正在执行。 二、多线程优缺点&#xff1a; 优点&#xff1a; 1、提高程序运行效率&#xff0c;如同时上传多个图片&#xff1b; 2、耗时操作放子线程执行&#xff0c;提高主线程执行效率&#xff0c;无需等待。 缺点&#…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023