So, I would like to stop using char* and char[ size ] to allocate and pass around strings. Instead I want to use a string class.

The string class allocates some memory on the stack (like 25 characters worth or so) to optimize the use of small strings. I have written a class that works the same, however, it also allows you to set the amount of 'stack allocated memory' using a template parameter. Like so:

MyString< SIZE > string;

This allows it to function just as if you were pre-allocating a char array like so:

char string[ SIZE ];

However, when I return a char array I just use a char*, and I don't need to know how much memory was allocated for that buffer. With MyString, when I return it I need to specify exactly how much memory was allocated for it, and it's a pain in the ass! Something like this:

const MyString< SIZE >& GetFaceName( );

Which is ridiculous, since I always have to know its exact size. How can I wrap char arrays into a class and make it not suck so bad? The only thing I can think of is to maybe have MyString inherit an interface IMyString and return that. But I'm not sure if that's the best way to solve this problem.

ALSO: Hope your Christmas was good!

Part of the reason I reimplemented std::string is because I wanted to have a string class that I could use as a replacement for preallocated character arrays, with the same performance characteristics and locality of memory.

To do that I require a string which allocates memory to the stack, and to specify the amount I want I need to pass it as a template parameter.

EDIT: Also, reimplementing std::string has little extra code due to it mostly calling into the methods of my reimplemented std::vector

Use an abstract base class:

class MyStringBase {
   public:
   virtual const char* GetAsChar () const = 0;
   virtual void SomeOtherFunction () = 0;
   };

template <uint32_t Size> class MyString : MyStringBase {
   public:
   virtual const char* GetAsChar () const { return data; }
   // ect...
   };

Or rework your functions to take a template parameter:

template <typename T> void PrintString (T&& s) {
   s.PrintOrSomeFunction();
   }

template <uint32_t S> void PringString2 (const MyString<S>& s) {
   s.PrintMoreStuff();
   }

Part of the reason I reimplemented std::string is because I wanted to have a string class that I could use as a replacement for preallocated character arrays, with the same performance characteristics and locality of memory.

To do that I require a string which allocates memory to the stack, and to specify the amount I want I need to pass it as a template parameter.

EDIT: Also, reimplementing std::string has little extra code due to it mostly calling into the methods of my reimplemented std::vector

I agree that replacing stl functions isn't necessary and will cost money and time, however, discussing when and how to do so is outside the scope of this thread.

As for the solution to my issue, it seems like the only way to do it is to use interfaces, as Ryan_001 suggested. This is because using template methods will not work with interfaces, and my interfaces need to be able to return strings.

Sadly, this precludes the use of template methods inside the MyString class as well, which thankfully in this case only adds a bit of extra header code.

I think I detect a bit of sarcasm in the second paragraph, and I note the issue you point out. Thankfully, I only need roughly 3 different sizes throughout my entire application, and the instruction cache can more than handle that.

Having said that, I do wonder if there is a better way. In the end, I simply want a string which allocates on the stack like a char[ Size ] array. Funnily enough, I'm not sure C++ is up to the task without major drawbacks one way or another (for example instruction cache bloat if overused). Maybe that's why everyone just passes around char*.