Skip to main content

Which string class consumes lower memory between std::string and FString in C++ using Unreal Engine

In many programming projects, strings are a fundamental data type that are used extensively to represent text, identifiers, and other types of data. However, strings can also consume a significant amount of memory, particularly if they are used extensively or if they contain large amounts of data. In a project that needs to save memory, it is important to carefully consider the memory usage of string objects and to take steps to minimize it.


When we use Unreal Engine, FString is easy to use class due to the convenience of functionalities and tight coupling of engine's overall structure. However in some specific situation, you can use std::string instead.

Let's check memory consumption of string classes.

// 13 characters
std::string MyStdString = "Hello, world!";
FString MyFString = "Hello, world!";
 
UE_LOG(LogTemp, Log, TEXT("allocated size[std::string] = %d"), MyStdString.capacity());
UE_LOG(LogTemp, Log, TEXT("allocated size[FString] = %d"), MyFString.GetAllocatedSize());

Result:
LogTemp: allocated size[std::string] = 15
LogTemp: allocated size[FString] = 28

(Both string classes have internal variables to store length of capacity and used characters)


In general, std::string uses less memory than FString in Unreal Engine.

std::string is part of the C++ standard library and is a simple string type that manages a contiguous block of characters in memory. It uses a fixed amount of memory that is proportional to the length of the string.

FString is a string class provided by Unreal Engine that offers additional functionality and features compared to std::string, such as support for localization and text formatting. However, this additional functionality comes at a cost in terms of memory usage, as FString uses a more complex memory management scheme to handle its features.

How about 100 characters?

// 100 characters
std::string MyStdString = "0123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789";    
FString MyFString = "0123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789";
 
UE_LOG(LogTemp, Log, TEXT("allocated size[std::string] = %d"), MyStdString.capacity());
UE_LOG(LogTemp, Log, TEXT("allocated size[FString] = %d"), MyFString.GetAllocatedSize());

Result:

LogTemp: allocated size[std::string] = 111 LogTemp: allocated size[FString] = 202


Obviously FString uses two times more memory than std::string.

Because FString stores its characters in a dynamically allocated buffer that can be resized as needed, which means that the size of an FString object can be significantly larger than the size of its contents. Additionally, FString supports Unicode characters, which can further increase its memory usage.

Therefore, if memory usage is a concern, std::string may be a better choice than FString in Unreal Engine. However, if you need the additional functionality provided by FString, you may have to accept the higher memory usage.


Considerations:

In Unreal Engine, the FString class provides features such as lazy initialization, copy-on-write semantics, and support for Unicode characters, all of which can help reduce the memory footprint of string objects in memory-constrained environments.

In addition to using optimized string classes, there are several other techniques that can be used to reduce memory usage when working with strings. These include using string pooling to reuse memory for frequently used strings, avoiding unnecessary copies of strings, and using string views to refer to substrings of larger strings without creating new string objects.

Conclusion:

The memory usage of string objects is an important consideration in any project that needs to save memory. By carefully selecting string classes, optimizing memory usage, and using best practices for working with strings, you can help ensure that your programs run smoothly and efficiently, even in memory-constrained environments.


References:



Comments

Post a Comment

Popular posts from this blog

How to load glTF models at runtime in C++ using Unreal Engine (glTFRuntime plugin)

Unreal Engine provides loading of 3D models stored in Content directory as a format of converted assets. However, In some project, you may need to load 3D models at runtime which cannot be stored at Content directory.  What is glTF? glTF is a standard format (ISO/IEC International Standard) for 3D asset delivery and interchange. Wide variety of application and service supports glTF. https://www.khronos.org/gltf/ glTFRuntime plugin You can use glTF 3D files in Unreal Engine thanks to the glTFRutime plugin .   https://github.com/rdeioris/glTFRuntime However, most of the documentation focuses on Blueprint usage. If you want to use this plugin in C++, you can use below example. (This plugin already provides AglTFRuntimeAssetActor class, but this class is derived from AActor to show how to use C++ APIs).    How to use glTF 3D model as a member component of an actor To use this plugin in my project, I had to use it as a member component of my pre-existing actor class....
Post a Comment
Read more