随手写的一些STL中vector，map等容器的测试代码，菜鸟请轻拍。。怕疼

最新推荐文章于 2024-07-24 20:03:15 发布
最新推荐文章于 2024-07-24 20:03:15 发布
阅读量666 收藏
点赞数
文章标签： stl map 标准 string
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq635938204/article/details/31777717
版权 
#include "stdafx.h"

#include <vector>
#include <list>
using namespace std;
#include <iostream>
#include <algorithm>
#include <string>
#include <set>


typedef struct TestStruct
{
	long lAge;
	char szName[32];
	int nSex;

	/*friend bool operator<(const TestStruct&t1,const TestStruct&t2)
	{
		return t1.lAge<t2.lAge;
	}*/

	/*bool operator()(const TestStruct&t1,const TestStruct&t2) const
	{
		return t1.lAge<t2.lAge;
	}*/
}MyTestStruct,*pMyTestStruct;

class TestStruct_Rules
{
public:
	bool operator()(const TestStruct&t1,const TestStruct&t2) const
	{
		return t1.lAge<t2.lAge;
	}
};

Test::Test()
{

}

Test::~Test()
{

}

BOOL isSort(long const& l1,long const& l2)
{
	return l1>l2;
}

void Test::VectorTest1()
{
	CString csTemp;
	vector<long> vTest1;
	vector<long> vTest2(vTest1);
	vector<long> vTest3(5);
	vector<long> vTest4(5,6);
	vector<string> vTest5(4,"2");

	vTest5.push_back("2");

	long lData[5]={9,2,6,3,8};
	list<long> lstTest1(lData,lData+5);
	/*
	vector<long> vTest6{1,2,3,4};
	vector<string> vTest7{4,"null"};
	vector<string> vTest8{"null","null","null"};
	*/



	MyClass myclass1;
	vector<MyClass> vTest9(1,myclass1);

	MyClass* myclass2=new MyClass;
	vector<MyClass*> vTest10(1,myclass2);

	long lData2[6]={10,2,5,6,11,0};
	vector<long> vTest11(lData2,lData2+6);

	size_t nSize=vTest1.size();
	csTemp.Format(_T("vTest1 Size = %d\r\n"),nSize);
	OutputDebugString(csTemp);

	nSize = vTest3.size();
	csTemp.Format(_T("vTest3 Size = %d\r\n"),nSize);
	OutputDebugString(csTemp);

	nSize = vTest4.size();
	csTemp.Format(_T("vTest4 Size = %d\r\n"),nSize);
	OutputDebugString(csTemp);

	csTemp.Format(_T("vTest3-- value0=%d,value1=%d\r\n"),vTest3[0],vTest3[1]);
	OutputDebugString(csTemp);

	csTemp.Format(_T("vTest4-- value0=%d,value1=%d\r\n"),vTest4[0],vTest4[1]);
	OutputDebugString(csTemp);

	csTemp.Format(_T("vTest4-- value0Addr=[%x],value1Addr=[%x]\r\nsizeof(long)=%d\r\n")
		,&vTest4[0],&vTest4[1],sizeof(long));
	OutputDebugString(csTemp);

	csTemp.Format(_T("vTest5-- value0Addr=[%x]\tvalue0=[%s]\r\nvalue1Addr=[%x]\tvalue1=[%s]\r\nsizeof(string)=%d\r\n")
		,&vTest5[0],vTest5[0].c_str(),&vTest5[1],vTest5[1].c_str(),sizeof(string));
	OutputDebugString(csTemp);
	csTemp.Empty();

#ifdef _DEBUG

	list<long>::iterator lst_ite=lstTest1.begin();
	csTemp.Format(_T("lstTest1-- value0=[%x]\r\n"),lst_ite);
	OutputDebugString(csTemp);
	csTemp.Format(_T("lstTest1-- value0=[%x]\r\n"),&(*lst_ite));
	OutputDebugString(csTemp);
	csTemp.Format(_T("lstTest1-- value1=[%d]\r\n"),*(++lst_ite));
	OutputDebugString(csTemp);

	csTemp.Format(_T("myclass1 Addr = [%x]\r\nvTest9--value0Addr=[%x]\r\nsizeof(MyClass)=%d\r\n")
		,&myclass1,&vTest9[0],sizeof(myclass1));
	OutputDebugString(csTemp);

	csTemp.Format(_T("size = %d\tcapacity = %d\r\n"),vTest4.size(),vTest4.capacity());
	OutputDebugString(csTemp);
	csTemp.Format(_T("value0Addr=[%x]\tvalue1Addr=[%x]\r\n"),&vTest4[0],&vTest4[1]);
	OutputDebugString(csTemp);
	vTest4.push_back(0);
	csTemp.Format(_T("value0Addr=[%x]\tvalue1Addr=[%x]\r\n"),&vTest4[0],&vTest4[1]);
	OutputDebugString(csTemp);
	csTemp.Format(_T("size = %d\tcapacity = %d\r\n"),vTest4.size(),vTest4.capacity());
	OutputDebugString(csTemp);
	vTest4.push_back(0);
	vTest4.push_back(0);
	vTest4.push_back(0);
	csTemp.Format(_T("size = %d\tcapacity = %d\r\n"),vTest4.size(),vTest4.capacity());
	OutputDebugString(csTemp);

	vector<long>(vTest4).swap(vTest4);
	csTemp.Format(_T("size = %d\tcapacity = %d\r\n"),vTest4.size(),vTest4.capacity());
	OutputDebugString(csTemp);

	vTest1.reserve(1000);
	csTemp.Format(_T("size = %d\tcapacity = %d\r\n"),vTest1.size(),vTest1.capacity());
	OutputDebugString(csTemp);
	for (int i = 1; i <= 1000; ++i) 
		vTest1.push_back(i);

	vector<long>::iterator ite=vTest4.begin();
	csTemp.Format(_T("Addr=[%x]\tvalue=[%x]\r\n"),&(*ite),(*(ite._Ptr)));
	OutputDebugString(csTemp);

	csTemp.Empty();
	for(long i=0;ite!=vTest4.end();++i,++ite)
	{
		if(!csTemp.IsEmpty()) csTemp.Append(_T(","));
		csTemp.AppendFormat(_T("%d"),vTest4[i]);
	}
	OutputDebugString(csTemp);
	OutputDebugString(_T("\r\n"));

	csTemp.Empty();
	vector<long>::const_reverse_iterator ite1=vTest4.crbegin();
	while (ite1 != vTest4.crend())
	{
		if(!csTemp.IsEmpty()) csTemp.Append(_T(","));
		csTemp.AppendFormat(_T("%d"),*ite1);
		++ite1;
	}
	OutputDebugString(csTemp);
	OutputDebugString(_T("\r\n"));
	delete myclass2;
	

	vTest4.clear();
	csTemp.Format(_T("size=[%d]\tcapacity=[%d]\r\n"),vTest4.size(),vTest4.capacity());
	OutputDebugString(csTemp);
	vTest4.push_back(11);
	csTemp.Format(_T("size=[%d]\tcapacity=[%d]\r\n"),vTest4.size(),vTest4.capacity());
	OutputDebugString(csTemp);
	
	csTemp.Format(_T("size=[%d]\tcapacity=[%d]\r\n"),vTest11.size(),vTest11.capacity());
	OutputDebugString(csTemp);
	csTemp.Empty();
	ite=vTest11.begin();
	for(long i=0;ite!=vTest11.end();++i,++ite)
	{
		if(!csTemp.IsEmpty()) csTemp.Append(_T(","));
		csTemp.AppendFormat(_T("%d"),vTest11[i]);
	}
	OutputDebugString(csTemp);
	OutputDebugString(_T("\r\n"));

	sort(vTest11.begin(),vTest11.end());
	csTemp.Empty();
	ite=vTest11.begin();
	for(long i=0;ite!=vTest11.end();++i,++ite)
	{
		if(!csTemp.IsEmpty()) csTemp.Append(_T(","));
		csTemp.AppendFormat(_T("%d"),vTest11[i]);
	}
	OutputDebugString(csTemp);
	OutputDebugString(_T("\r\n"));

	sort(vTest11.begin(),vTest11.end(),isSort);
	csTemp.Empty();
	ite=vTest11.begin();
	for(long i=0;ite!=vTest11.end();++i,++ite)
	{
		if(!csTemp.IsEmpty()) csTemp.Append(_T(","));
		csTemp.AppendFormat(_T("%d"),vTest11[i]);
	}
	OutputDebugString(csTemp);
	OutputDebugString(_T("\r\n"));
	csTemp.Empty();
	csTemp.Format(_T("%x"),&vTest11[0]);

	vTest11.push_back(11);
	vTest11.push_back(10);
	vTest11.push_back(2);
	csTemp.Empty();
	csTemp.Format(_T("%x"),&vTest11[0]);
	vTest11.reserve(20);
	csTemp.Empty();
	csTemp.Format(_T("%x"),&vTest11[0]);
	ite=vTest11.begin();
	csTemp.Empty();
	for(long i=0;ite!=vTest11.end();++i,++ite)
	{
		if(!csTemp.IsEmpty()) csTemp.Append(_T(","));
		csTemp.AppendFormat(_T("%d"),vTest11[i]);
	}
	OutputDebugString(csTemp);
	OutputDebugString(_T("\r\n"));
	csTemp.Empty();
	csTemp.Format(_T("%x"),&vTest11[0]);

	csTemp.Empty();
	for (auto autotest : vTest11)
	{
		if(!csTemp.IsEmpty()) csTemp.Append(_T(","));
		csTemp.AppendFormat(_T("%d"),autotest);
	}
	OutputDebugString(csTemp);
	OutputDebugString(_T("\r\n"));

	csTemp.Empty();
	sort(vTest11.begin(),vTest11.end());
	auto end_unique=unique(vTest11.begin(),vTest11.end());
	//vTest11.erase(end_unique,vTest11.end());
	for (auto autotest : vTest11)
	{
		if(!csTemp.IsEmpty()) csTemp.Append(_T(","));
		csTemp.AppendFormat(_T("%d"),autotest);
	}
	OutputDebugString(csTemp);
	OutputDebugString(_T("\r\n"));
	vector<long>().swap(vTest11);
	//{ std::vector<int> tmp = v;   v.swap(tmp);   }; 
#endif

	//vector<string> v4{"t","e"};
	vector<long> vTest12;
	//vTest12.size(10000001);
	//vTest12.reserve(10000001);
	/*long lCurrTime = ::GetTickCount(),lTime(0);
	for(long i=0;i<10000000;++i)
	vTest12.push_back(i);
	lTime = ::GetTickCount()-lCurrTime;
	csTemp.Format(_T("Time = [%3f]s\r\n"),(double)lTime/1000);
	OutputDebugString(csTemp);*/
}


/
MyClass::MyClass():m_lStatus(0)
{
	memset(m_chName,0,sizeof(m_chName));
}

MyClass::~MyClass()
{
}

/

BOOL isMapSort(const pair<CString,long>& data1,const pair<CString,long>& data2)
{
	return data1.second<data2.second;
}

BOOL isMapSort2(const pair<long,long>&d1,const pair<long,long>&d2)
{
	return d1.second<d2.second;
}

MapTest::MapTest()
{

}

MapTest::~MapTest()
{

}

void MapTest::MapTest1()
{
	CString csTemp;
	map<CString,long> mapTest1;
	multimap<CString,long> mapTest2;
	set<string> setTest1;

	//mapTest1.push_back(_T("test"),1);

	mapTest1.insert(make_pair(_T("沙僧"),0));
	mapTest1.insert(make_pair(_T("唐僧"),1));
	mapTest1.insert(make_pair(_T("白龙马"),3));
	mapTest1.insert(make_pair(_T("沙僧"),4));
	mapTest1.insert(make_pair(_T("玉帝"),0));
	mapTest1.insert(make_pair(_T("唐僧"),5));
	mapTest1.insert(make_pair(_T("孙悟空"),6));

	//sort(mapTest1.begin(),mapTest1.end());

	//map<string,string> authors={{"test","test"},{"test","test"}};

	mapTest2.insert(make_pair(_T("沙僧"),0));
	mapTest2.insert(make_pair(_T("唐僧"),1));
	mapTest2.insert(make_pair(_T("白龙马"),3));
	mapTest2.insert(make_pair(_T("沙僧"),4));
	mapTest2.insert(make_pair(_T("玉帝"),0));
	mapTest2.insert(make_pair(_T("唐僧"),5));
	mapTest2.insert(make_pair(_T("孙悟空"),6));

	multimap<long,long> mapTest4;
	mapTest4.insert(make_pair(1,1));
	mapTest4.insert(make_pair(8,1));
	mapTest4.insert(make_pair(5,1));
	mapTest4.insert(make_pair(2,1));
	mapTest4.insert(make_pair(3,1));
	mapTest4.insert(make_pair(4,1));


	/*
	pair标准库类型，定义在utility头文件中
	一个pair保存两个数据成员，由特定的类型模板
	*/
	pair<CString,long> name;
	//pair<CString,long> name1{_T("test"),1};
	pair<CString,long> name2(_T("test"),1);
	//pair<CString,long> name3={_T("test"),1};


	typedef map<CString,long>::key_type v1;
	v1  csTest = _T("test");
	typedef map<CString,long>::value_type v2;

	//map<string,int>::mapped_type v3;

	map<CString,long>::iterator ite1=mapTest1.begin();

	while(ite1!=mapTest1.end())
	{
		ite1->first;
		++ite1;
	}


	mapTest1.erase(_T("沙僧"));

	set<int> iset;
	int iData[10]={7,8,9,0,1,2,3,4,5,6};
	iset.insert(iData,iData+10);
	set<int>::iterator ite =iset.find(1);
	long lPos = iset.count(8);

	//mapTest1.equal_range();
	//sort(mapTest4.begin(),mapTest4.end(),isMapSort2);
	pair<CString,long> mappair;
	map<CString,long>::iterator ite2,ite3,ite4;
	auto pos = mapTest1.equal_range(_T("猪八戒"));
	typedef map<CString,long>::iterator  pp1;
	pair<pp1,pp1> pos1 = mapTest1.equal_range(_T("猪八戒"));
	int i(0);
	if(pos.first == pos.second)
		i=1;
	else i=2;

typedef pair<CString,long> pp;

	

	//pair<pp,pp> pairTemp(mapTest1.equal_range(_T("猪八戒")));
	ite2 = mapTest1.lower_bound(_T("唐僧"));
	ite3 = mapTest1.upper_bound(_T("唐僧"));
	pos = mapTest1.equal_range(_T("唐僧"));

	vector<pair<CString,long>> vTemp;
	for (map<CString,long>::iterator curr = mapTest1.begin();curr!=mapTest1.end();curr++)
	{
		vTemp.push_back(make_pair(curr->first,curr->second));
	}
	sort(vTemp.begin(),vTemp.end(),isMapSort);
	vector<pair<CString,long>>::iterator ite6=vTemp.begin();
	//sort(mapTest1.begin(),mapTest1.end(),isMapSort);
	while (ite6!=vTemp.end())
	{
		csTemp.Format(_T("key=%s\t-->\tvalue=%d\r\n"),ite6->first,ite6->second);
		OutputDebugString(csTemp);
		ite6++;
	}
	OutputDebugString(_T("---------------------------------------\r\n"));
	
	
	map<CString,long> mapTest3;

	mapTest3[_T("tangseng")] = 1001;
	mapTest3[_T("sunwukong")] = 2002;
	mapTest3[_T("zhubajie")] = 3003;
	mapTest3[_T("bailongma")] = 4004;
	mapTest3[_T("guanyin")] = 5005;
	map<CString,long>::iterator ite5=mapTest3.begin();
	/*map<CString,long>::key_compare mycomp = mapTest3.key_comp();
	CString highest = mapTest3.rbegin()->first;
	do 
	{
		csTemp.Format(_T("key=%s\t-->\tvalue=%d\r\n"),ite5->first,ite5->second);
		OutputDebugString(csTemp);
	} while (mycomp((*ite5++).first, highest));

	OutputDebugString(_T("---------------------------------------\r\n"));*/

	pair<CString,long> highest1 = *mapTest3.rbegin();
	map<CString,long>::reverse_iterator ite7 = mapTest3.rbegin();
	ite5 = mapTest3.begin();
	do 
	{
		csTemp.Format(_T("key=%s\t-->\tvalue=%d\r\n"),ite5->first,ite5->second);
		OutputDebugString(csTemp);
	} while (mapTest3.value_comp()(*ite5++,highest1));
	OutputDebugString(_T("---------------------------------------\r\n"));

	ite5 = mapTest3.begin();
	while (ite7 != mapTest3.rend())
	{
		while(!(mapTest3.value_comp()(*ite5,*ite7)))
		{
			csTemp.Format(_T("key=%s\t-->\tvalue=%d\r\n"),ite5->first,ite5->second);
			OutputDebugString(csTemp);
			ite7++;
			if(ite7==mapTest3.rend()) break;
			ite5 = mapTest3.begin();
		}
		ite5++;
	}
	mapTest1.swap(mapTest3);

	mapTest1.insert(v2(_T("test"),1));

	map<MyTestStruct,long,TestStruct_Rules> mapTest5;
	mapTest5.clear();

	MyTestStruct mystruct;
	memset(&mystruct,0,sizeof(MyTestStruct));
	for (long i=0;i<5;i++)
	{
		mystruct.lAge=i*10;
		strncpy_s(mystruct.szName,"沙僧",31);
		mystruct.nSex = i/2;
		mapTest5.insert(make_pair(mystruct,i));
		memset(&mystruct,0,sizeof(MyTestStruct));
	}
	m_MyData.swap(mapTest1);
}

BOOL MapTest::MapTest2(map<CString,long>& maptest)
{
	maptest.insert(make_pair(_T("test"),1));
	return TRUE;
}

map<CString,long>& MapTest::MapTest3()
{
	return m_MyData;
}

map<CString,long>* MapTest::MapTest4()
{
	return &m_MyData;
}

/

StringTest::StringTest()
{

}

StringTest::~StringTest()
{

}



void StringTest::StringTest1()
{
#ifdef UNICODE
	std::wstring strTemp=_T("e:\\newGGDevelop\\Client\\release\\config\\system\\res\\FlexPaper\\DocumentView.htm?openType=DER&filetype=pdf&guid=E95EAAF3-00B0-40FA-AA84-2E54EACE2D0B&filepages=3&Download=1"),strTemp2;
	int nValue(-1);
	wstring::size_type pos,pos2,pos3;
	std::wstring strKey(_T("filetype=")),strWords(_T("doc|docx|txt|rar|zip|xls|xlsx|ppt|pptx"));
	pos = strTemp.find(strKey);
	if(pos != strTemp.npos)
	{
		pos2 = strTemp.find(L"&",pos);
		if(pos2 != strTemp.npos && pos2>pos)
		{
			strTemp2 = strTemp.substr(pos+strKey.length(),pos2-pos-strKey.length());
			pos3 = strWords.find(strTemp2);
			if(pos3!= strWords.npos)
				nValue =0;
			else
			{
				std::string strPath="C:\\1.pdf";
				char path[MAX_PATH] = {0};
				strncpy_s(path,strPath.c_str(),MAX_PATH);
				OpenFolderAndSelectFile(path);
			}
		}
	}
#else
#endif
}



BOOL OpenFolderAndSelectFile( LPSTR lpszFilePath)
{
	//
	// GetFolder
	//
	DWORD dw = lstrlenA(lpszFilePath) - 1;
	for (;dw != -1;dw--)
	{
		if ( lpszFilePath[dw] == '\\')
		{
			break;
		}
	}
	if ( dw == -1)
	{
		return FALSE;
	}
	//
	// Get a pointer to the Desktop's IShellFolder interface.
	// 
	LPSHELLFOLDER pDesktopFolder;
	if ( SUCCEEDED(SHGetDesktopFolder( &pDesktopFolder)))
	{
		// 
		// IShellFolder::ParseDisplayName requires the file name be in
		// Unicode.
		// 
		OLECHAR oleStr[MAX_PATH];

		lpszFilePath[dw] = '\0';
		MultiByteToWideChar( CP_ACP, MB_PRECOMPOSED,
			lpszFilePath, -1, oleStr, _countof(oleStr));
		// 
		// Convert the path to an ITEMIDLIST.
		// 
		LPITEMIDLIST     pidl;
		ULONG             chEaten;
		ULONG             dwAttributes;
		HRESULT             hr;

		hr = pDesktopFolder->ParseDisplayName(
			NULL, NULL, oleStr, &chEaten, &pidl, &dwAttributes);
		if (FAILED(hr))
		{
			pDesktopFolder->Release();
			return FALSE;
		}
		LPCITEMIDLIST pidlFolder = pidl;

		lpszFilePath[dw] = '\\';
		MultiByteToWideChar(CP_ACP, MB_PRECOMPOSED,
			lpszFilePath, -1, oleStr, _countof(oleStr));

		hr = pDesktopFolder->ParseDisplayName(
			NULL, NULL, oleStr, &chEaten, &pidl, &dwAttributes);
		if (FAILED(hr))
		{
			pDesktopFolder->Release();
			return FALSE;
		}
		LPCITEMIDLIST pidlFile = pidl;

		CoInitialize( NULL);
		hr = SHOpenFolderAndSelectItems( pidlFolder, 1, &pidlFile, 0);

		pDesktopFolder->Release();

		if ( hr == S_OK)
		{
			return TRUE;
		}
	}
	return FALSE;
}

--夜凉如水--
关注
C++中对hash_map自定义哈希函数和比较函数的理解
独自奋斗的那些日子
09-24 4665
首先申明一下，我是菜鸟，真正的菜鸟，不是谦虚。所以很多地方有错误，需要大家指出。我只是为了记录，顺便加深自己的理解，不是为了炫耀什么。             这两天学习使用hash_map，在网上搜索了一下，没搜到详细介绍hash_map工作原理的内容（可能是我的搜索方式有问
关于Vector和Map查找效率的惊人的实际测试结果
热门推荐
HW140701的博客
04-25 2万+
最近在项目中有一种结构体数据需要存储，数据结构体如下 typedef mystruct { int ID; ......//其他的数据成员 double pinwei; }; 原本数据是由一个Vector存储的，Vector<mystruct> m_Vector; 现在需要根据在m_Vector中的每一个结构体的ID来获得其对应的pinwe...
标准模板库（STL）之 vector 用法【初级】
Aliven888的博客
08-12 184
标准模板库（STL）之 vector 用法【初级】
验证码破解技术四部曲之使用卷积神经网络（四）
weixin_34161029的博客
09-24 190
前言 在这节，我将用卷积神经网络（简称：CNN）破解新浪微博手机端的验证码(http://login.weibo.cn/login/)，验证码如下。 本节的代码可以在https://github.com/nladuo/captcha-break/tree/master/weibo.cn找到。 关于神经网络的原理很难在一节讲清楚。在这里，只...
使用map的find头文件_C++ map 根据value找key的实现
weixin_39966644的博客
12-22 939
flyfish测试所需头文件#include #include #include #include 初始std::map t;t.insert(std::make_pair(1, "a"));t.insert(std::make_pair(2, "b"));t.insert(std::make_pair(3, "c"));t.insert(std::make_pair(4, "d"));根据key...
关于map的应用的小题
wu546547的博客
04-12 303
这是题目 // Practice.cpp: 定义控制台应用程序的入口点。 // #include "stdafx.h" #include<iostream> #include<map> #include<vector> #include<algorithm> using namespace std; bool cmp(const pair<i...
STL标准模板库---容器篇(一)
U2396573637的博客
07-24 1077
对C风格字符串的封装，也是容器类的“先驱”类，也可以称为“实验品”，但这只是相对而言。字符串类string本身功能还是非常强大的。string str;//声明字符串变量//初始化字符串变量//使用重载后的操作符 + 连接两个字符串字符串类还提供了许多成员函数来操作字符串，以下是一些常用的成员函数：size():返回字符串的长度empty():检查字符串是否为空substr():获取子字符串find():查找子字符串在主字符串中的位置replace():替换字符串中的某些字符。
请写出你知道的stl容器
06-12
好的，我可以列举一些STL容器，包括： 1. vector：动态数组，支持快速随机访问和在末尾插入或删除元素。 2. list：双向链表，支持快速插入或删除元素，但不支持随机访问。 3. deque：双端队列，支持在两端快速...
基于STL技术的演讲比赛
09-14
在演讲比赛中，参赛者可能通过具体的案例分析、性能测试和代码优化展示了STL的使用技巧和最佳实践。 总之，STL是C++程序员不可或缺的工具，理解和掌握STL能够提升开发效率，编写出更加高效、优雅的代码。无论是初学...
2012VC++ 编程指南【适合菜鸟】极其详细.zip
01-01
5. **STL（Standard Template Library）标准模板库**：STL是C++中的一大利器，包括容器（如vector、list、map）、算法和迭代器。学习如何利用STL提高代码效率和可读性。 6. **异常处理**：介绍C++的异常处理机制，...
STL源码分析目录
啦啦啦
12-11 3367
SIG STL源码分析 前言 本专栏主要以STL源码剖析分析路线来分析SIGSTL3.0源码. 整个模块准备对学习STL源码剖析之后做一个系统的总结, 这些都是我个人的理解, 如果分析有什么问题欢迎各位大佬们指出. 也很感谢作者以及网络中各个大佬的总结, 让我也能更容易更深刻的理解到STL强大和方便, 也让我对template感受深刻. 以下是我自己对STL版块进行分析. 总共分为六个版块 : 空...
【PCL】点云库PCL常见错误
GordonWei
03-13 6187
本文转载于 《点云库PCL从入门到精通常见的编译错误》 原文连接：https://blog.csdn.net/jacken123456/article/details/105361314 （1）error c4996: ‘fopen’: This function or variable may be unsafe 解决方法：项目->属性->配置属性->C/C++ -> 预处理器 -> 预处理器定义，增加： _CRT_SECURE_NO_DEPRECATE。 参考博文：http
PCL NARF关键点提取
钢铁男儿
05-18 1183
NARF关键点提取 1、背景 关键点也称为兴趣点，是通过定义检测标准来获取的具有稳定性、区别性的点集。从技术上来说，关键点的数量要比原始点云的数目少很多，与局部特征描述子结合在一起，组成关键点描述子常用来形成原始数据的紧凑表示，而且不失代表性与描述性，从而加快识别、追踪有等对数据的处理速度。故而，关键点提取就成了2D和3D信息处理中不可或缺的关键技术。 本例程将点云数据生成深度图数据，然后对深度图数据进行关键点提取，最后将关键点在点云视图中进行可视化。 2、关键点提取代码 //提取NARF关键.
C++ vector和iterator简单用法
zyh的打怪历程
05-13 1万+
vector是动态可变数组，可以添加int、double、自定义的类 1.int示例： #incldue&lt;vector&gt; vector&lt;int&gt; a; a.push_back(1); a.push_back(2); a.push_back(3); for(vector&lt;int&gt;::iterator iter = a.begin();iter != a.end...
c#实现俄罗斯方块，面向对象实现
09-15
俄罗斯方块（Tetris）是一款经典的益智游戏，由俄罗斯程序员阿列克谢·帕基特诺夫于1984年开发。游戏的主要目标是通过旋转和移动不同形状的方块（称为“砖块”或“Tetrominoes”），将它们填充到屏幕底部的水平行中。当一行被完全填满时，该行会消失，玩家将获得积分。 游戏特点： 砖块形状：游戏中有七种不同形状的砖块，每种砖块由四个方块组成。 下落机制：砖块从屏幕顶部逐渐下落，玩家需要快速做出决策。 得分系统：消除的行越多，得分越高，连续消除多行会获得额外分数。 难度递增：随着游戏进行，砖块下落的速度会逐渐加快，增加了游戏的挑战性。 文化影响： 俄罗斯方块不仅在游戏界取得了巨大的成功，还成为了流行文化的一部分，影响了许多后续的游戏设计。它的简单性和上瘾性使其成为了历史上最畅销的电子游戏之一。 版本与平台： 自发布以来，俄罗斯方块已经在多个平台上推出，包括家用游戏机、电脑、手机等，形成了众多不同的版本和变种。
5G网络优化案例：关于解决诺基亚5G 700M站点小区闪断问题解决.pdf
09-15
这份文件是关于解决诺基亚5G 700M站点小区闪断问题的详细案例报告，主要内容和关键要点如下： 问题背景与初步分析： 问题描述：随着5G 700M网络建设的推进，诺基亚700M现网出现较多误码告警和小区闪断问题，故障比例明显高于其他厂家站点。 初步定位：通过归类法分析，发现绝大部分误码问题发生在烽火单芯双向光模块小区，占比高达95.65%。 故障根因深入探究： 光模块适配问题：初步认为烽火单纤双向光模块存在问题，但更换后问题依旧，进一步分析为光模块与诺基亚设备的适配问题。 深入测试与定位：选取5个长期误码小区进行深入分析，与烽火厂家合作对光模块进行程序升级，问题得到初步解决。 AUTOBYPASS机制分析： 机制介绍：烽火光模块采用25G模块速率兼容10G，并开启AUTOBYPASS（CPR自动旁路模式）功能。 影响分析：AUTOBYPASS机制与诺基亚设备不适配，导致交互失败和误码产生。关闭AUTOBYPASS后，CDR时钟校验和恢复周期缩短，交互频繁，误码问题消失。 解决方案与实施： 解决方案：针对所有使用此类光模块的诺基亚站点，通过优化升级烽火光模块，关闭AUTOBYPASS功
在线请假管理系统.zip
09-15
这是一个基于Python Flask的Web应用程序，采用Bulma uI框架和Postgresql数据库，用于管理和处理员工的请假事宜。用户可以通过这个系统创建安全的用户账户并登录，员工可以提交请假申请等待上级审批，并查看历史请假记录。经理可以审批或拒绝员工的请假申请，并查看团队的请假记录。此外，管理员还可以查看所有员工信息，添加新员工并分配经理，编辑和删除员工信息。该项目在heroku上托管，提供在线服务。安装步骤包括克隆项目、创建虚拟环境、激活环境并安装依赖项等。还提供了数据库迁移和初始化、运行应用程序以及数据重置等实用工具命令。 1、资源项目源码均已通过严格测试验证，保证能够正常运行； 2、项目问题、技术讨论，可以给博主私信或留言，博主看到后会第一时间与您进行沟通； 3、本项目比较适合计算机领域相关的毕业设计课题、课程作业等使用，尤其对于人工智能、计算机科学与技术等相关专业，更为适合； 4、下载使用后，可先查看README.文md件（如有），本项目仅用作交流学习参考，请切勿用于商业用途。
performance-timing.js利用HTML5的navigation_timing_API_performance
最新发布
09-15
performance-timing.js利用HTML5的navigation_timing_API_performance-timing
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值