Initialize read only array only once

Question

I have a class that needs to use some big arrays, initialized via some complex functions, that will be the same for every instance and will only be read after initialization.

I searched on SO and found some answers on initializing static arrays like this:

char A::a[6] = {1,2,3,4,5,6};

But in my case I need to calculate the arrays at runtime via some function. (How) can I do it?

Answer 1

Re

” will be the same for every instance and will only be read after initialization

Producing a value is the job of a function.

Just define a function that returns the data you need.

You can use it to initialize a static data member (or whatever). For a header only module, if that's relevant, you will need to employ solution to the "inline data" problem, eg a Meyers' singleton (a function that returns a reference to a local static variable). Like this:

#include <vector>

namespace my {
    using std::vector;

    inline
    auto squares()
        -> vector<int>
    {
        vector<int> result;
        for( int i = 1; i <= 12; ++i ) { result.push_back( i*i ); }
        return result;
    }

    class A
    {
    private:
        static
        auto a()
            -> const vector<int>&
        {
            static const vector<int> the_values = squares();
            return the_values;
        }

    public:
        A(){}
    };
}  // namespace my

Answer 2

You can't use {} sintaxis in execution time, you can use a method:

class A
{
   static vector<char> a;
   //...
   public:
   static void initStatic();
}

void A::initStatic()
{
    a.resize( /*put the size here... */);
    for (auto& x : a)
        x = //something...
}

vector reference: http://en.cppreference.com/w/cpp/container/vector

Answer 3

If you aren't using vectors, this works. The reason I let A::initialize do the work, rather than just calling one of these externally defined functions, is that we can and should expect the data member a to be private.

//Declare a function pointer type, so you can pass it into A's
//an initialization function takes in the array and its size
typedef void (*initFunction) (char A[], int arraySize); 
//see http://www.cprogramming.com/tutorial/function-pointers.html
//  for more on function pointers

class A
{
public:
  void initialize (initFunction myInitFunction);
  ...
private:
  char a[ARRAYSIZE];
};

void A::initialize (initFunction myInitFunction)
{
   (*myInitFunction) (a, ARRAYSIZE);  
}

...
A myA;
myA.initialize (yourArrayInitializingFunction);

Or maybe your initialization functions don't take in arrays and initialize them, but return arrays:

class A
{
public:
  void initialize (const char* aInit);
  ...
};

void A::initialize (const char* aInit)
{
   for (int i = 0; i < ARRAYSIZE: ++i)
     a[i] = aInit[i];
}

...

A myA;
myA.initialize (yourArrayReturningFunction ());

If you're using vectors, code is simpler:

class A
{
public:
  void initialize (const vector<char>& aInit) { a = aInit; }
  ...
private:
  vector<char> a;
};

Answer 4

My suggestion:

1. Instead of using a static member variable, use a static member function to provide access to the array.

2. In the static member function, create a static function variable that can be populated the first time it is needed.

Here's what I am thinking of:

char* A::getArray()
{
   static char a[6] = {0};
   static bool inited = false;
   if ( !inited )
   {
      // Initialize the array elements 
      a[0] = ...  ;

      ...

      a[5] = ...  ;

      inited = true;
   }

   return a;
}