Define array size in library without modifying it for every new use?

Question

Example: The class (library) uses array of default fixed size. Let's say 64 bytes. In the program, however, you may need bigger size, lets say 128 bytes. What would be the best approach, if you don't want to rewrite the library every time?

I tried to demonstrate this by following WRONG code (using #ifndef #define):

// myClass.h *****************************************

#ifndef myClass_h
#define myClass_h

#ifndef EXAMLPE
#define EXAMLPE 64
#endif

class myClass{
        ...
    private:
        byte myArray[EXAMLPE];  // Use EXAMLPE to allocate array
}

#endif


// Program.ino ***************************************

// Override the default value without modifying the library
#define EXAMLPE 128
#include "myClass.h"
// this does not work because of different scope, says compiler

EDIT: I want make fixed size array as it is easy and it is considered as good practise on 2kb RAM platform

EDIT 2: I don't understand all the arguing in the comment and also why my question is down rated. I'm not a great programmer of course, I do not know anything about vectors, nor templates, and that's why I'm asking here for help.

I'm looking for a method, how to set fixed size array in library from main code in compile time.

And finally: Does anyone know why do I get compile error EXAMPLE was not declared in this scope when I delete #ifndef EXAMPLE ... #endif lines from header? Isn't it suppose to be scope independent?

Answer 1

Compile-time

If your size is defined at compile time, you could use a template class, with the size as template argument.

template<int EXAMPLE>
class myClass{
        ...
    private:
        byte myArray[EXAMPLE];  
};

or you could use the std::array container.

vs. Run time

However fixed sized arrays are not very flexible. I'd therefore strongly advise to use vectors instead. Not only can you set a default size for your vector, but this size can be adapted dynamically without you having to worry about memory management, copy constructors, assignment operators, etc...

class myClass {
    public: 
        myClass(int mysize=64) : myVector(mysize) {}       
    private:
        std::vector<byte> myVector;  // no size needed here
};

Answer 2

C++ does not support runtime sized arrays. Therefore if you do not know at compile time what size of memory you will need an array is the wrong tool for the job. I would instead suggest having your object contain only a pointer, and then use new to dynamically allocate the data block based on some runtime value.

Note the following code is just to demonstrate the idea expressed above and is not tested, and probably does not compile.

class myClass {
private:
    byte *myData;
public:
    myClass(std::size_t dataSize) :
            myData(new byte[dataSize])
    {}
    myClass(const myClass&) = delete;
    myClass(myClass&&) = delete;
    myClass& operator=(const myClass&) = delete;
    myClass& operator=(myClass&&) = delete;
    ~myClass()
    {
        delete[] myData;
    }
};

If on the other hand, the size is known at compile time, but you dont wish to edit the header file every time you need to change the size you could instead use a template class, these allow users to provide compile time parameters when they use the class. For example:

template<size_t dataSize>
class myClass {
private:
    byte myArray[dataSize];
};

The class can then be created with a custom size known at compile time as follows:

auto foo = myClass<128>();

Answer 3

Why not substitute the use of an array for a vector and define methods to manipulate the max size of the vector. So something like:

#include <vector>


myClass{

private:
    vector<int> v;
    int maxSize
public:
  myClass(int size){
      v.reSize(size);
      maxSize = size;

  }
  void add(int byte){
      if(v.size()<maxSize){
          v.push_back
      }
  }
}

Answer 4

The Arduino IDE does some tricks when converting the .ino files to a single .cpp file

• create function prototypes
• eventually reorder #include (?)

This could postpone your

#define EXAMLPE 128

The template solution is best for arduino, I think. vectors and dynamic mem usage is very dangerous with 2kB RAM (on an UNO) only.