游戏开发常用字符串函数整理【C++版】

最新推荐文章于 2024-04-21 21:26:55 发布
最新推荐文章于 2024-04-21 21:26:55 发布
阅读量981 收藏
点赞数
分类专栏： 游戏开发 文章标签： 游戏开发过程中常用的 函数参考python 觉得有些细节不够优 可以自行处理
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Unknowm/article/details/52577798
版权

游戏开发过程中常用的，函数参考python；

觉得有些细节不够优化的，可以自行处理。


/************************************************************************/
/*      UT_BaseStringUtility.h                                          */
/************************************************************************/
#pragma once

#include 
   
   
    
    
#include 
    
    
     
     


typedef    std::string                        StdString;
typedef    std::vector
     
     
      
                 StdStringVector;


namespace UT_String
{
	bool                    startsWith(const StdString& str, const StdString& strSub, bool caseSensitive = true );
	bool                    endsWith(const StdString& str, const StdString& strSub, bool caseSensitive = true );
	bool                    contains(const StdString& str, const StdString& strSub, bool caseSensitive = true );
	StdStringVector         split( const StdString& rkString , char cSplit );
	StdStringVector         split( const StdString& rkString , const StdString& sSplit );
	StdStringVector         partition( const StdString& rkString , const StdString& sSplit );
	StdStringVector         rpartition( const StdString& rkString , const StdString& sSplit );
	StdString               join( const StdString& sJoin , const StdStringVector& sSeqs );
	int                     compare(const StdString& rklv,const StdString& rkrv,bool bCasesensitive = false);
	void                    trim(StdString& str, bool left = true , bool right = true, const char * my_replace_delims = NULL, const char * my_external_delims = NULL );
	void                    remove(StdString& str, const StdString& strSub);
	StdString               replace(const StdString& kMainString, const StdString& kSrc, const StdString& kDst);
	StdString               left(const StdString& str, StdString::size_type nCount);
	StdString               right(const StdString& str, StdString::size_type nCount);
	StdString               mid(const StdString& str, StdString::size_type nPos, StdString::size_type nCount = StdString::npos);
	StdString::size_type    indexOf(const StdString& str, const StdString& strSub);
	int                     format(StdString& str, const char *szFormat, ...);

	void                    toLower(StdString& str);
	void                    toUpper(StdString& str);
	StdString               lower(const StdString& str);
	StdString               upper(const StdString& str);

	int                     toInt(const StdString& str);
};



/************************************************************************/
/*     UT_BaseStringUtility.cpp                                         */
/************************************************************************/
#include "UT_BaseStringUtility.h"
#include 
      
      
       
       

namespace	UT_String
{
#define JZChar          char
#define JZString        StdString
#define JZStringVector  StdStringVector
	//-------------------------------------------------------------------------
	bool startsWith(const JZString& str, const JZString& strSub, bool caseSensitive )
	{
		if (strSub.empty())				// l_sub == 0
			return false;

		size_t l = str.length();
		size_t l_sub = strSub.length();	// l_sub > 0
		if (l_sub > l)
			return false;

		if (caseSensitive)
		{
			int x = str.compare(0, l_sub, strSub);
			return x == 0;
		}

		for (size_t i = 0; i < l_sub; i++)	// not caseSensitive
		{
			int c = str[i];
			int d = strSub[i];

			c = tolower(c);
			d = tolower(d);

			if (c != d)
			{
				return false;
			}
		}

		return true;
	}
	//-------------------------------------------------------------------------
	bool endsWith(const JZString& str, const JZString& strSub, bool caseSensitive )
	{
		if (strSub.empty())				// l_sub == 0
			return false;

		size_t l = str.length();
		size_t l_sub = strSub.length();	// l_sub > 0
		if (l < l_sub)
			return false;

		int diff = (int)(l - l_sub);	// l >= l_sub
		if (caseSensitive)
		{
			int x = str.compare(diff, l_sub, strSub);
			return x == 0;
		}

		for (size_t i = 0; i < l_sub; i++)	// not caseSensitive
		{
			int c = str[i + diff];
			int d = strSub[i];

			c = tolower(c);
			d = tolower(d);

			if (c != d)
			{
				return false;
			}
		}

		return true;
	}
	//-------------------------------------------------------------------------
	bool contains(const JZString& str, const JZString& strSub, bool bCaseSensitive )
	{
		if (bCaseSensitive)
			return str.find(strSub) != str.npos;

		JZString kLv = str;
		JZString kRv = strSub;

		std::transform(str.begin(),str.end(),kLv.begin(),tolower);
		std::transform(strSub.begin(),strSub.end(),kRv.begin(),tolower);

		return kLv.find(kRv) != kLv.npos;
	}
	//-------------------------------------------------------------------------
	JZStringVector split( const JZString& rkString , char cSplit )
	{
		JZStringVector kResult;
		kResult.reserve(1);

		JZString kFormatPath = rkString;
		JZString::size_type kPos = kFormatPath.find_first_of(cSplit);
		if ( kPos == JZString::npos )
		{
			if (!kFormatPath.empty())
				kResult.push_back( kFormatPath);
			return kResult;
		}

		JZString kSubPath = kFormatPath;

		while(kPos != JZString::npos && kFormatPath.length() > 0)
		{
			kSubPath = kFormatPath.substr(0,kPos);
			kFormatPath = kFormatPath.substr(kPos + 1);

			kResult.push_back(kSubPath);

			kPos = kFormatPath.find_first_of(cSplit);
		}
		if ( kPos == JZString::npos && kFormatPath.length() > 0 )
		{
			kResult.push_back( kFormatPath );
		}
		return kResult;
	}
	//-------------------------------------------------------------------------
	JZStringVector split( const JZString& rkString , const JZString& sSplit )
	{
		JZStringVector kResult;
		kResult.reserve(1);

		JZString kFormatPath = rkString;
		JZString::size_type kPos = kFormatPath.find(sSplit);
		if ( kPos == JZString::npos )
		{
			if (!kFormatPath.empty())
				kResult.push_back( kFormatPath);
			return kResult;
		}

		JZString kSubPath = kFormatPath;

		while(kPos != JZString::npos && kFormatPath.length() > 0)
		{
			kSubPath = kFormatPath.substr(0,kPos);
			kFormatPath = kFormatPath.substr(kPos + sSplit.length());

			kResult.push_back(kSubPath);

			kPos = kFormatPath.find(sSplit);
		}
		if ( kPos == JZString::npos && kFormatPath.length() > 0 )
		{
			kResult.push_back( kFormatPath );
		}
		return kResult;
	}
	//-------------------------------------------------------------------------
	JZStringVector partition( const JZString& rkString , const JZString& sSplit )
	{
		JZStringVector kResult;
		kResult.reserve(3);

		JZString kFormatPath = rkString;
		JZString::size_type kPos = kFormatPath.find_first_of(sSplit);
		if ( kPos == JZString::npos )
		{
			kResult.push_back( kFormatPath);
			kResult.push_back( JZString());
			kResult.push_back( JZString());

			return kResult;
		}
		else
		{
			JZString p0 = kFormatPath.substr(0,kPos);
			JZString p2 = kFormatPath.substr(kPos + sSplit.length());

			kResult.push_back(p0);
			kResult.push_back(sSplit);
			kResult.push_back(p2);
		}

		return kResult;
	}
	//-------------------------------------------------------------------------
	JZStringVector rpartition( const JZString& rkString , const JZString& sSplit )
	{
		JZStringVector kResult;
		kResult.reserve(3);

		JZString kFormatPath = rkString;
		JZString::size_type kPos = kFormatPath.find_last_of(sSplit);
		if ( kPos == JZString::npos )
		{
			kResult.push_back( JZString());
			kResult.push_back( JZString());
			kResult.push_back( kFormatPath);

			return kResult;
		}
		else
		{
			JZString p0 = kFormatPath.substr(0,kPos);
			JZString p2 = kFormatPath.substr(kPos + sSplit.length());

			kResult.push_back(p0);
			kResult.push_back(sSplit);
			kResult.push_back(p2);
		}

		return kResult;
	}
	//-------------------------------------------------------------------------
	JZString join( const JZString& sJoin , const JZStringVector& sSeqs )
	{
		JZString	ret;
		for (JZStringVector::const_iterator it = sSeqs.begin(); it != sSeqs.end(); ++it)
		{
			ret.append(*it);
			ret.append(sJoin);
		}
		if (sSeqs.size() > 0)
			ret.erase(ret.length() - sJoin.length());

		return ret;
	}
	//-------------------------------------------------------------------------
	int compare(const JZString& rklv, const JZString& rkrv,bool bCaseSensitive)
	{
		if(bCaseSensitive)
			return  rklv.compare(rkrv.c_str());

		JZString kLv = rklv;
		JZString kRv = rkrv;

		std::transform(rklv.begin(),rklv.end(),kLv.begin(),tolower);
		std::transform(rkrv.begin(),rkrv.end(),kRv.begin(),tolower);

		return  kLv.compare(kRv.c_str());
	}
	//-------------------------------------------------------------------------
	void trim( JZString& str, bool left, bool right, const JZChar * my_replace_delims/* = NULL*/, const JZChar * my_external_delims/* = NULL*/ )
	{
		static const JZString s_default_delims = " \t\r\n";
		const JZString delims = my_replace_delims ? my_replace_delims : (my_external_delims ? s_default_delims + my_external_delims :s_default_delims);
		if(right)
			str.erase(str.find_last_not_of(delims)+1); // trim right
		if(left)
			str.erase(0, str.find_first_not_of(delims)); // trim left
	}
	//-------------------------------------------------------------------------
	void remove( JZString& str, const JZString& strSub )
	{
		JZString::size_type nCount = strSub.length();
		JZString::size_type nPos = str.find(strSub);
		while (nPos != JZString::npos)
		{
			str.erase(nPos, nCount);
			nPos = str.find(strSub, nPos+1);
		}
	}
	//-------------------------------------------------------------------------
	JZString replace(const JZString& kMainString, const JZString& kSrc, const JZString& kDst)
	{
		JZString rkResult = kMainString;
		JZString::size_type pos = 0;
		JZString::size_type srcLen = kSrc.size();
		JZString::size_type dstLen = kDst.size();
		while ( (pos = rkResult.find(kSrc, pos)) != JZString::npos )
		{
			rkResult.replace(pos, srcLen, kDst);
			pos += dstLen;
		}

		return rkResult;
	}
	//-------------------------------------------------------------------------
	JZString		left(const JZString& str, JZString::size_type nCount)
	{
		if( nCount >= str.length() )
			return JZString(str);

		return str.substr(0, nCount);
	}
	//-------------------------------------------------------------------------
	JZString		right(const JZString& str, JZString::size_type nCount)
	{
		if( nCount >= str.length() )
			return JZString(str);

		return str.substr(str.length() - nCount);
	}
	//-------------------------------------------------------------------------
	JZString		mid(const JZString& str, JZString::size_type nPos, JZString::size_type nCount)
	{
		if( nPos >= str.length() )
			return JZString(str);

		return str.substr(nPos, nCount);
	}
	//-------------------------------------------------------------------------
	JZString::size_type	indexOf(const JZString& str, const JZString& strSub)
	{
		return str.find(strSub);
	}
	//-------------------------------------------------------------------------
	int 	format(JZString& str, const JZChar *szFormat, ...)
	{
		int len = 0;
		JZChar tempStr[1024];

		va_list ArgPtr;	
		va_start( ArgPtr, szFormat );
		len += vsprintf_s(tempStr, 1023, szFormat, ArgPtr);
		va_end( ArgPtr );

		str = tempStr;

		return len;
	}
	void		toLower(JZString& str)
	{
		std::transform(str.begin(),str.end(),str.begin(),tolower);
	}
	void		toUpper(JZString& str)
	{
		std::transform(str.begin(),str.end(),str.begin(),toupper);
	}
	JZString		lower(const JZString& str)
	{
		JZString kResult = str;
		std::transform(str.begin(),str.end(),kResult.begin(),tolower);
		return	kResult;
	}
	JZString		upper(const JZString& str)
	{
		JZString kResult = str;
		std::transform(str.begin(),str.end(),kResult.begin(),toupper);
		return	kResult;
	}
	//-------------------------------------------------------------------------
	int				toInt(const JZString& str)
	{
		return atol(str.c_str());
	}

#undef JZChar
#undef JZString
#undef JZStringVector
}	//namspace

Unknowm
关注
专栏目录
C++软件调试与异常排查从入门到精通系列文章汇总
dvlinker的技术专栏
06-29 19万+
根据近几年排查软件异常的实践与经验，系统地讲解了C++软件异常常见原因与常用排查方法，以图文并茂的方式给出具体的分析实例，带领大家逐步掌握C++软件异常排查的相关技术与要领。
c++游戏开发中用到的函数
渣萌大表哥
11-24 1430
memset（）函数 函数原型：void * memset( void * ptr, int value, size_t num ); 功能：将ptr所指向的某一块内存中的每个字节的内容全部设置为value指定的 memset(m_TCalculateBoard,0,sizeof(m_TCalculateBoard)); memset(&Tsendcardfinish, 0,sizeo
c++游戏常用函数
qybcjmy的博客
07-31 1067
这个函数可以设置输出字符的颜色，但不能设置背景颜色。这个函数很实用，可以把光标移动到指定位置；
Unity游戏开发常用的一些函数用法
weixin_33769207的博客
07-14 534
Unity游戏开发常用函数 本文提供全流程，中文翻译。 Chinar 坚持将简单的生活方式，带给世人！（拥有更好的阅读体验 —— 高分辨率用户请根据需求调整网页缩放比例） Chinar —— 心分享、心创新！助理快速了解 Unity 开发中常用的一些基础函数为新手节省宝贵的时间，避免采坑！ Chinar 教程效果： 1 ...
如何用C++做游戏(2)
sinat_36098122的博客
06-12 3986
上一节讲了一些基本的Lua应用，或许你会说，还是很简单么。呵呵，恩，是的，本来Lua就是为了让大家使用的方便快捷而设计的。如果设计的过为复杂，就不会有人使用了。下面，我要强调一下，Lua的栈的一些概念，因为这个确实很重要，你会经常用到。熟练使用Lua，最重要的就是要时刻知道什么时候栈里面的数据是什么顺序，都是什么。如果你能熟练知道这些，实际你已经是Lua运用的高手了。说 真的，第一次我接触栈的时候...
C/C++游戏编程开发
shaoqun2005的博客
03-12 2647
C/C++游戏编程开发，采用的是Win32/64下编程，利用的开发工具是VS2008，本套教程针对那些喜欢游戏开发的人是非常不错的教程，学习要求，有C/C++编程功底，可以不是很高，但是至少也要学习到函数这个地步，才能进行本视频的学习，本视频的课程实验全是老师一行行代码的编写，不会出现复制粘贴的情况，这也是为了方便学习者能够跟上学习思路，以及编程思路古下伏笔，以下是该视频的课程目录：如果你会一点C、
c++字符串操作函数集合整理c++字符串操作函数集合整理[借鉴].pdf
10-11
C++字符串操作函数是编程中常用的功能，尤其是在处理文本数据时。本篇文章将对一些重要的C++字符串操作函数进行详细讲解，包括bcmp、bcopy、bzero、index、memccpy和memchr等，这些都是C语言标准库`<string.h>`中的...
整理C语言和C++中常用输入输出函数
m0_66029639的博客
01-23 2272
1.C语言中的输入与输出 在C语言中我们常用输入函数“scanf”和输出函数“printf”，而与之配套的格式符有 程序如下： #include<stdio.h>//C语言版 #include<string.h> int main() { int a;//定义一个整数 float b;//定义一个单精度浮点数 double c;//定义一个双精度浮点数 char d;//定义一个字符 char e[110];//定义一组字符串
C C++字符串基础，类型，使用方法大全(字符，字符串(1)
最新发布
m0_54903333的博客
04-21 650
不能插入和删除数组元素有时候会非常麻烦，比如一个数组保存了某个班级的学生学号，现在有一名学生退学了，就得把 TA 从数组中剔除，但是C语言并不支持这么做，这就给编程带来了不小的麻烦。
C++头文件常用函数整理与应用
理解并熟练掌握这些头文件及其功能是C++编程中必不可少的基础，它们为开发人员提供了丰富的工具，以便高效地处理数据输入、输出、字符串操作、数学计算和算法实现。通过结合使用这些函数，可以构建出功能强大的C++...
C++游戏编程
10-21
已更新的原创C++编程游戏，好玩带感的游戏。全部代码可复制！！！
《C++游戏编程入门》(Beginning C++ Game Programming)
12-27
语 言：英语 作 者：Michael Dawson 出版社：Course Technology PTR ISBN：1592002056 简介： Interactivity?the unique feature that sets games apart from other forms of entertainment. The power of interactivity lies in the programming that occurs behind the scenes. If you?re ready to jump into the world of programming for games, "Beginning C++Game Programming" will get you started on your journey, providing you with a solid foundation in the game programming language of the professionals. As you cover each programming concept, you?ll create small games that demonstrate your new skills. Wrap things up by combining each major concept to create an ambitious multiple player game. Get ready to master the basics of game programming with C++! 目录： Table of Contents Introduction Chapter 1 - Types, Variables, and Standard I/O: Lost Fortune Chapter 2 - Truth, Branching, and The Game Loop: Guess My Number Chapter 3 - For Loops, Strings, and Arrays: Word Jumble Chapter 4 - The Standard Template Library: Hangman Chapter 5 - Functions: Mad-Lib Chapter 6 - References: Tic-Tac-Toe Chapter 7 - Pointers: Tic-Tac-Toe 2.0 Chapter 8 - Classes: Critter Caretaker Chapter 9 - Advanced Classes and Dynamic Memory: Game Lobby Chapter 10 - Inheritance and Polymorphism: Blackjack
C++游戏编程.pdf
09-21
C++游戏编程.pdf C++游戏编程.pdf C++游戏编程.pdf
C++游戏编程教程（三）
[PE]经典八炮的博客
10-04 5640
在上一篇博客里，我们介绍了SDL基本的函数用法，今天，我们就来研究一下Game类的代码。让我们再次打开模板项目。 注：在代码中，用到了一个头文件Math.h（不是C语言中的math.h），这是那本书的作者自己编写的一个头文件，非常有用，点击此处下载。一定要把解压后的Math.h和Math.cpp加入到项目里，才能编译通过。 Game类代码 先上代码： Game.h #pragma once #include "SDL.h" #include <unordered_map> #include &l
游戏开发之类的构造函数和析构函数（C++基础）
田螺姑娘的博客
08-22 202
游戏开发之类的构造函数和析构函数（C++基础） 构造函数数**主要作用在于创建对象时为对象的成员属性赋值， 构造函数由编译器自动调用， 无须手动调用。 析构函数主要用于对象销毁前系统自动调用， 执行一些清理工作。 构造函数语法： 构造函数函数名和类名相同， 没有返回值， 不能有void, 但可以有参数。 类名(形参列表){函数体} 析构函数语法： 析构函数函数名是在类名前面加”~”组成,没有返回值， 不能有 void,不能有参数， 不能重载。 ~类名(){函数体} 类的构造函数按照参数类型分类：分为无
《C++游戏编程入门》第5章 函数:Mad Lib
yxqq378287007的博客
03-12 447
Standard Template Library，提供算法、容器和迭代器等。全局变量，程序各部分间共享信息（任意部分都能访问的变量）。短小函数，直接复制到调用处，程序不必跳转。函数名相同，形参个数或类型不相同。变量作用域决定可见范围。为函数形参指定默认值。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值