Question

Is this allowable?

class object 
{
public:
    struct st_example {
        int i;
        int j;
        int c[d];
        st_example(int i_i, J_j, d_d) : i(i_i), j(j_j), d(d_d) {}
    };

    object(int i_ii, int j_jj, int d_dd)
    {
        struct st_example test(i_ii, j_jj, d_dd);
    }; // Constructor
};

So that:

object testObj(1,2,3);

Answer 1

What’s d in st_example? I don’t see any variable d, so
you can’t initialize it, nor use it in an expression.

If you simply want st_example to contain an array whose size
is determined at runtime, use std::vector. Trying to do it as
you do cannot be made to work; you define a local st_example,
and the compiler has to know how much space to allocate for it,
at compile time.

If all cases of st_example are allocated dynamically, there
are some dirty tricks you can play:

class st_example
{
public:
    int i;
    int j;
    int size;
    int* c() { return reinterpret_cast<int*>( this + 1 ); }
    int const* c() const { return reinterpret_cast<int const*>( this + 1 ); }
    void* operator new( size_t toAllocate, int n )
    {
        st_example* results =
            static_cast<st_example*>(
                ::operator new( toAllocate + n * sizeof(int) ) );
        results->size = n;
        return results;
    }
    void operator delete( void* p )
    {
        ::operator delete( p );
    }
    void operator delete( void* p, int );
    {
        ::operator delete( p );
    }
    st_example(int i, int j)
        : i(i)
        , j(j)
    {
    }
};

(Formally, this is undefined behavior; The standard does not
guarantee that values set in the operator new will still be
there in the constructor. In practice, however, it will work.)

Client code has to allocate using new (d) st_example(i, j),
and access to elements of c is c()[i]. And in the more
general case, you’ll likely have to worry about alignment.
(Here, everything is int, so the alignment works out
automatically.)

I’d recommend sticking with std::vector, however. It’s a lot
simpler, and a lot less fragile.