struct Data 
{
  int a;
  int b;
  std::string c;
};

struct Base
{
  int sz;  
  Data d[1];
};

void doSomething(Base *b)
{
  for (int i = 0; i < b.sz; ++i)
  {
    std::cout << b->d[i].a << b->d[i].s << '\n';  /// *************
  }
}

struct Der11
{
  Base b;
  Data d[10];
};

void func()
{
  Der10 d;
  d.sz = 11;
  doSomething(&d.b);
}

E>struct Data {};
E>struct Base
E>{
E>  int sz;  
E>  Data d[1];
E>};

E>struct Der11
E>{
E>  Base b;
E>  Data d[10];
E>};

E>

struct Base
{
  std::vector<Data>  d;
};

void func()
{
  Der10 d;
  d.d.resize(10);
  doSomething(&d.b);
}

template<int N>
struct Base
{
  Data  d[N];
};

struct Der10 : public Base<10>
{};

template<int N>
void doSomething(Base<N> *b)
{
  for (int i = 0; i < N; ++i)
  {
    std::cout << b->d[i].a << b->d[i].s << '\n';  /// *************
  }
}

void func()
{
  Der10 d;
  doSomething(&d.b);
}

J>struct Base
J>{
J>  std::vector<Data>  d;
J>};
J>

struct Base
{
 Data *d;
 int sz;
};

struct Der11
{
  Der11() { d = dt; sz = 11; }
  Data dt[11];
};

J>template<int N>
J>struct Base
J>{
J>  Data  d[N];
J>};

J>struct Der10 : public Base<10>
J>{};

J>template<int N>
J>void doSomething(Base<N> *b)
J>

struct OtherBaseData
{
  int a, b, c;
};

template<int N>
struct Base
{
  OtherBaseData obd;
  Data  d[N];
};

void int_doSomething(OtherBaseData *obd, Data *d, int d_sz);

template<int N>
void doSomething(Base<N> *b) { int_doSomething(&b->obd, b->d, N); }

E>У меня не везде есть stl и даже куча

E>но захотелось сэкономить указатель

.h:
template<int N>
void doSomething(Base<N> *b);

.cpp:
template<int N>
void doSomething(Base<N> *b)
{
    .. bzzz
}

template void doSomething<1>(Base<1>* );
template void doSomething<10>(Base<10>* );

static_assert((std::is_standard_layout<Der11>::value && (offsetof(Der11, Der11::d) == sizeof(Base))), "invalid layout");

A standard-layout class is a class that:
— has no non-static data members of type non-standard-layout class (or array of such types) or reference,
— has no virtual functions (10.3) and no virtual base classes (10.1),
— has the same access control (Clause 11) for all non-static data members,
— has no non-standard-layout base classes,
— either has no non-static data members in the most derived class and at most one base class with
non-static data members, or has no base classes with non-static data members, and
— has no base classes of the same type as the first non-static data member.

struct Base
{
  int sz;  
  Data d[1];
};