C ++类，数组成员的大小由CTOR传递

Question

Why I cannot have m_data array as a member like this?

class Array
{
private:
    const int m_capacity;
    int m_data[m_capacity];

public:
    Array(const int capacity = 100);
};


Array::Array(const int capacity /*= 100*/)
    : m_capacity(capacity)
{

}

And how I can achieve this without dynamic memory allocation?

Answer 1

In this case the compiler can't know the size of class Array and it can't determine size of such object. If objects of indeterminate compile-time size were allowed, the entire language would be different.

However, if you know capacity at compile time, you can write

template <int Size = 100>
class Array
{
private:
    int m_data[Size];

public:
    Array();
};

Then, to use it, you can do

Array<> a; //size = 100
Array<250> b; //size = 250

As @Superlokkus mentioned in comment, C++11 std::array is just a better implementation with same concept.

Answer 2

I would suggest use std::array instead of building your own wheel

#include <array>
template< unsigned long N >
using Array = std::array<int, N>;

And use Array as a normal templated class

Array<100> arr;

If you are keen on 100-sized array, it is even simpler

using Array = std::array<int, 100>;
Array arr;

Answer 3

Either you can declare a template class like this

#include <iostream>

template <size_t N = 100>
class Array
{
private:
    const size_t m_capacity = N;
    int m_data[N];

public:
    Array();
};

template <size_t N>
Array<N>::Array() : m_data {}
{
}

int main() 
{
    Array<> a1;
    Array<10> a2;

    return 0;
}

Or you should use data member

std::vector<int> m_data;

instead of the array.

Answer 4

You can't have an object whose size is chosen at runtime without dynamic allocation. You can have it without naked new / delete ; the normal class encapsulating that requirement is std::vector .

Alternatively, you can have a family of classes of different sizes. The normal class for that is std::array .