// This is totally a hack and just done for fun. // // The idea is to replace std::string's internal array with a new one without using any of its member functions // This totally depends on the implementation of std::string. This version was made under GCC 8.1.0 and may or may not work elsewhere // // // The layout of the string is as follows: // // std::string has 4 member variables, or more, the last one may as well be multiple ints instead of size_t, luckely the last one doesn't matter. // 1) A pointer to the internal array, offset of 0 // 2) The size of the array, offset of 8 // 3) The capacity of the array offset of 16 // 4) Dunno, sometimes its value is 16, sometimes its 54, sometimes 0, not sure what it is used for, any guesses? offset of 24 // // and as always, "no output." is sololearn's issue. #include #ifdef __GNUG__ #include #include static_assert( sizeof( std::string ) == 32, "The size of std::string should be 32 for this code to work" ); constexpr int PointerOffset = 0; constexpr int SizeOffset = 8; constexpr int CapacityOffset = 16; template unsigned char* castToBytes( const T& data ) { return const_cast(reinterpret_cast(&data)); } void printBytes( unsigned char* bytes, size_t size ) { for( size_t i = 0; i < size; ++i ) std::cout << (int)bytes[i] << ' '; } size_t readData( unsigned char* bytes, size_t offset, size_t length ) { assert( length <= 8 ); size_t data = 0; for( size_t i = 0; i < length; ++i ) { data |= bytes[i+offset] << (i * CHAR_BIT); } return data; } void writeData( void* destination, void* source, size_t offset, size_t length ) { memcpy( destination + offset, source, length ); } #endif // __GNUG__ int main() { #ifdef __GNUG__ // The test string std::string test_string = "string"; // Make sure string does not use the small string optimization test_string.reserve( 100 ); // The string we are going to replace the test string with const char* replacement = "\"Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.\""; size_t replacement_size = strlen( replacement ); // Get the underlying bytes for std::string unsigned char* bytes = castToBytes( test_string ); std::cout << "Underlying bytes of std::string before replacement:\n"; printBytes( bytes, sizeof( std::string ) ); std::cout << "\n\n"; // Read std::string's internal pointer char* pointer = (char*)readData( bytes, PointerOffset, sizeof( void* ) ); // New array size is gonna match the replacement size size_t new_size = replacement_size; // Make a new array char* new_pointer = new char[new_size]{}; // Delete the old pointer to prevent a memory leak delete[] pointer; // Copy the replacement string to the new array std::copy( replacement, replacement + replacement_size, new_pointer ); // Write the new capacity writeData( bytes, &new_size, CapacityOffset, sizeof( size_t ) ); // Write the new size writeData( bytes, &new_size, SizeOffset, sizeof( size_t ) ); // Write the new pointer writeData( bytes, &new_pointer, PointerOffset, sizeof( void* ) ); std::cout << "Underlying bytes of std::string after replacement:\n"; printBytes( bytes, sizeof( std::string ) ); std::cout << "\n\n"; test_string += "\n---\nAdding data still works!"; std::cout << test_string << '\n'; #else std::cout << "Sorry, this probably doesn't work outside GCC :("; #endif // __GNUG__ }

char* to string hack