Although this function name is indeed quite long, there's no easy way to simplify it nor is it too difficult to understand once you gain decent C++ development experience, using std especially. The TLDR answer is that this is a constructor for a
std::string object (specifically this looks like the substring(3) constructor, but I'm not 100% sure).
If you visit the
std::string reference page, you'll see this is the definition for
typedef std::basic_string<char> string;
std::string class is being defined using the
std::basic_string class template, which has three template parameters:
- the character type used for the string object.
- an object to control some string traits.
- The allocator used to actually allocate the string buffers for the class.
std::string case, however, only the first template parameter is provided - the other two are the default ones defined based on the first template parameter (char), and although they can be replaced with different or more complex traits or allocators, this isn't the case for the
Although the typedef string is pretty simple and straightforward thanks to the default templates parameters being unspecified, when the object is built and actually defined by the compiler the full definition is used, which adds a lot of boilerplate definitions.
If we split it up to it's parts, we'll see
std::basic_string is being used and three template parameters are specified. As mentioned for the
std::string, the second (
std::char_traits<char>) and third (
std::allocator<char>) are derived by the first and are both templates by themselves, receiving the same template parameter
std::basic_string got (
After the class definition, the two colons indicate a definition of an object under the class namespace:
::basic_string<char,std::char_traits<char>,std::allocator<char>>(void *Dst, _BYTE *a2, __int64 a3)
We can easily see this is a function that has the same name as the class itself, which is the known way to define a constructor.
Lastly, as with every function we have the parameters this function accepts inside the parentheses:
void *Dst, _BYTE *a2, __int64 a3
To simplify the full definition back to
std::basic_string<char>, one would need to hold the default template parameters for all std template classes, and strip the ones that are recognized as the default ones. Although this is not a very difficult task, it seems a little redundant to me. You are obviously encouraged to either develop such a plugin yourself or suggest the feature improvement to the IDA development team.