C++路径拼接性能对比：stringstream与C风格实现

温以宁

发布时间：2026-10-15 | 2人浏览过

原创

在C++开发中，处理文件路径拼接时若需兼顾性能，传统STL方式往往因内存分配开销导致瓶颈。本文通过实战对比std::stringstream实现与低层级的C风格指针操作，展示了如何将路径拼接速度提升至原来的十倍以上。

问题背景：C++11标准库的缺失

C++11 标准库并未提供类似 Python os.path 或 Java File 那样便捷的路径拼接方法。开发者通常需要自行处理目录分隔符（Windows 下的 \ 或 Linux 下的 /）以及相对路径中的 . 和 .. 解析逻辑。这种自定义实现的常见挑战在于如何平衡代码可读性与执行效率。

第一种方案：基于 stringstream 的 STI 实现

利用 C++ STL 的特性，可以通过 std::stringstream 结合字符串替换功能来实现路径规范化与拼接。该方法的逻辑是先统一分隔符，再按分隔符拆分目录部分，最后合并。

第 1 步：定义字符串替换辅助函数

首先需要一个函数用于将路径中的正斜杠统一替换为反斜杠（以适配 Windows 环境），以便后续统一处理：

string& replace_str(string& str, const string& to_replaced, const string& newchars)
{
	for (string::size_type pos(0); pos != string::npos; pos += newchars.length())
	{
		pos = str.find(to_replaced, pos);
		if (pos != string::npos)
			str.replace(pos, to_replaced.length(), newchars);
		else
			break;
	}
	return str;
}

第 2 步：实现路径拼接主逻辑

核心函数 combinePath 接受目录和文件名两个字符串参数。它先将输入转为 std::deque<std::string> 存储的各段路径，处理 . 和 .. 的逻辑（如遇到 .. 则移除栈顶目录），最后重组字符串。

// windows
std::string combinePath(const char *dir, const char* name)
{ 	
	//printf("%s + %s\n", dir, name);
	if (dir == nullptr || name == nullptr)
		return "";
	string temp = dir;
	replace_str(temp, "/", "\\");
	std::stringstream oss(temp);
	std::deque<std::string> vecDir;
	std::deque<std::string> vecName;

	string part;
	while (std::getline(oss, part, '\\'))
	{
		if (part.length() == 0)
			continue;
		vecDir.emplace_back(part);
	} 

	temp = name;
	replace_str(temp, "/", "\\");
	oss.clear();
	oss.str(temp);
	while (std::getline(oss, part, '\\'))
	{
		if (part.length() == 0)
			continue;
		vecName.emplace_back(part);
	}

	int index = 0;
	while (index < vecName.size())
	{
		if (vecName[0] == ".")
		{
			vecName.pop_front();
		}
		else if (vecName[0] == "..")
		{
			vecName.pop_front();
			if (vecDir.size() > 1)
				vecDir.pop_back();
		}
		else
		{
			vecDir.emplace_back(vecName[0]);
			vecName.pop_front();
		}
	}

	oss.clear();
	oss.str("");
	for (int i=0; i<vecDir.size(); i++)
	{
		oss << vecDir[i];
		if (vecDir.size() == 1 || i < (vecDir.size() - 1))
		{
			oss << "\\";
		}
	} 
	return oss.str();
}

第 3 步：验证测试结果

经过多组用例测试（包含 d:\\temp\\robin\\ 配合 ..\\demo\\config.ini 等场景），在 Release 模式且开启 O2 优化后，该实现平均耗时在 2~4 微秒 左右。虽然功能完善，但对于高频调用的底层模块而言，性能仍有提升空间。

第二种方案：基于 C 风格指针的高性能实现

为了突破性能瓶颈，我们可以跳过 STL 的对象管理开销，直接使用 C 风格的字符数组操作。该方法通过手动遍历、指针偏移和 memcpy 直接在预分配的缓冲区中构建结果。

第 1 步：引入逆向查找辅助函数

在处理 .. 向上跳转逻辑时，需要从当前缓冲区的末尾向前查找最后一个反斜杠的位置：

// 字符串范围内，逆向查找
const char * strrfind(const char *begin, const char *end, const char c)
{
	const char * buf = end;
	while (buf >= begin)
	{
		if (*buf == c)
			return buf;
		buf--;
	}
	return nullptr;
}

第 2 步：实现零拷贝拼接逻辑

函数 combinePathC 预先计算所需总长度并分配堆内存。随后，它逐个字符扫描 name 部分，遇到正常路径片段使用 memcpy 追加；遇到 .. 时，定位并截断之前的目录层级；忽略 . 和多余的分隔符。

size_t combinePathC(char ** buffer, const char * dir, const char *name)
{
	int n1 = strlen(dir);
	int n2 = strlen(name);
	size_t len = n1 + n2 + 2;
	char *buf = new char[len];
	*buffer = buf;

	memcpy(buf, dir, n1);
	size_t len1 = n1;

	// 末尾保证有一个"
	if (buf[n1-1] == '\\')
	{
		len1 = n1;
	}
	else
	{
		buf[n1] = '\\';
		len1 = n1+1;		
	}
	buf[len1] = '\0';

	// len1++示当前拼接的长度
	size_t index = 0;
	char * rPart = (char *)name;
	size_t len2 = n2;
	while (index < n2) // 使用index向后滑动，直到末尾
	{
		// 滑动后当前位置
		rPart = (char *)name + index;
		char * tmp = (char *)strchr(rPart, '\\');
		if (tmp == nullptr) // end here
		{
			// 拼接剩下的
			len2 = n2 - index;
			memcpy(buf + len1, rPart, len2);
			len1 += len2;
			buf[len1] = '\0';
			len1++;

			break;
		}

		// 当前找到的长度
		len2 = tmp - rPart;
		if (len2 == 0) 	 // 遇到 "
		{
			index += 1;
		}
		else if (len2 == 1 && rPart[0] == '.') // 遇到 ".\",
		{
			index += 2;
		}
		else if (len2 >= 2 && rPart[0] == '.') // 遇到 "..",
		{
			index += len2 + 1;
			const char * back = strrfind(buf, buf + len1 - 2 , '\\');
			if (back == nullptr)
			{
				// dir 当前是这样的情况，"d:
			}
			else if ((back - dir) == 2) 
			{
				len1 = 3;
				buf[3] = '\0';
			}
			else 
			{
				len1 = back - buf + 1;
				buf[len1] = '\0';
			}
		}
		else 	 // 
		{
			index += len2 + 1;
			memcpy(buf + len1, name + index, len2 + 1);
			len1 += len2 + 1;
		}
	} 
	return len1;
}