Instantiating a class on Stack memory

I have the following class which I wish to instantiate on stack memory:

class ClassOnStack {
   int arr[];

public:
    
   ...
   // somemethods();
}

I have three requirements, two of which are:

1. I wish to specify the size of arr while instantiating it through a constructor.
2. I want to instantiate this class entirely on stack. That is the array 'arr' should also be stored on stack.

The way I came up with is using templates and making new operator private.

template<int ARRAY_LEN>

class ClassOnStack {

private:
  void *operator new(size_t size); //overloaded and private                                                                                                                                               

public:
  int array[ARRAY_LEN];

  ClassOnStack() {
  }

  ....
  // somemethods()
};

However this will require me to define the methods within the header file which I don't wish to do.
The third requirement is:

3. I wish to keep the implementation in the cpp file.

What are other approaches I can take ?

To satisfy your number 2 and 3 requirements:

To keep the core implementation in the .cpp file and still be a template class on the stack, you could probably use the details pattern.

Declare your class that has the core implementation like this:

class ClassOnStackDetails {
private:
    int* _arr;
    size_t _arraySize;
public:
    ClassOnStackDetails(int* arr, size_t arraySize);
    void doSomething();
    int doSomethingElse();
};

Then your template class, the one that actually gets instantiated on the stack, can be declared in the same header file or in another that #includes the previous declaration. The template class constructor just passes the array and its compile time size to the details class as a pointer. The public methods of the template class just forward to the details class where the implementation is not in the header file.

template <size_t ARRAY_LEN>
class ClassOnStack {

public:
    std::array<int, ARRAY_LEN> arr;

    ClassOnStack() : arr(), _details(arr.data(), arr.size()) {
        
    }

    void doSomething() {
        _details.doSomething();
    }

    int doSomethingElse() {
        return _details.doSomethingElse();
    }

private:
    ClassOnStackDetails _details;

};

Take note that I explicitly declared _details after arr. If your real work gets more complicated, you can add an explicit init function to the details class that gets called by the template class constuctor.

Then your .cpp file has the implementation for ClassOnStackDetails:

#include "ClassOnStack.h"

ClassOnStackDetails::ClassOnStackDetails(int* arr, size_t arraySize) :
_arr(arr),
_arraySize(arraySize) {
   // additional intitialization
}


ClassOnStackDetails::doSomething() {
   // your code goes here
}

int ClassOnStackDetails::doSomethingElse() {
   // your code goes here
}

Then in code, you can simply say:

int foo() {
    ClassOnStack<52> deckOfCards;
}

Something like this works without any use of heap memory, with alloca(3):

#include <alloca.h>
#include <stddef.h>
class ClassOnStack {
 public:
  ClassOnStack(size_t size, int *buf): size_(size), buf_(buf) {}
  // ...
 private:
  // ...
  size_t size_;
  int *buf_;
};
#define ALLOCA_SIZE_AND_BUF(size) (size), alloca(size)

Use it like this:

ClassOnStack cs(ALLOCA_SIZE_AND_BUF(size));

Unfortunately it's too easy to use it incorrectly, e.g. if the user accidentally calls the constructor directly, and the forgets to destroy the data buf_ points to. It's possible to make that harder, but it's not possible to get rid of the macro.