Can I use a template to set array size?

Question

So, I'm new to using templates, and I have a question. Since templates are handled at compile time, and array size has to be set at compile time, can I use a template to set array size?

template<const size_t N> struct Stats {
    // Member functions (omitted).

    // The stats themselves.
    int stats[N];
};

class DudeWithStats {
    public:
        void setStats(int sts[], size_t sz, bool derived = false);

        // Other member functions (omitted).

    private:
        Stats<8> base;
        Stats<5> derived;

        // Other member variables (omitted).
};

void DudeWithStats::setStats(int sts[], size_t sz, bool drvd /* = false */) {
    for (int i = 0; i < sz; i++) {
        if (drvd) {
            derived.stats[i] = sts[i];
        } else {
            base.stats[i] = sts[i];
        }
    }
}

int main() {
    int arrBase[8] = { 10, 20, 10, 10, 30, 10, 15, 6 };
    int arrDerived[5] = { 34, 29, 42, 100, 3 };

    DudeWithStats example;
    example.setStats(arrBase, 8);
    example.setStats(arrDerived, 5, true);
}

I can see making a dynamic array with new or std::vector working out, but I'm curious as to whether this would work.

(Yes, I know const is meaningless in template declaration, at least to the compiler. It's mainly there for documentation.)

Thanks in advance.

(Edit: Noticed I had the default argument in setStats()' definition. Fixed that. Fixed the function itself, too, I believe (never had to directly copy an array before).)

(Edit: Switched it to a size_t. Still working on getting setStats() to work, I'll probably just stick with passing the stats manually instead of as an array.)

(Edit: Just used a workaround to get setStats() working. It looks a bit awkward, but it's good enough for test code.)

---

Thanks for answering and helping, everyone. I'll use something similar to that for what I need, and improve it as I get better at coding.

Answer 1

Yes. Yes, you can.

template <size_t N>
void foo()
{
   // 100% standard-compliant and fine
   bool array[N] = {};
}

Answer 2

You're completely right about the templates stuff. Templates are (maybe too?) flexible, with a system that (IMHO) is only compared by Haskell's.

Anyway, GCC won't like your code:

c.cpp:21:57: error: default argument given for parameter 2 of ‘void DudeWithStats::setStats(int*, bool)’ [-fpermissive]
 void DudeWithStats::setStats(int* sts, bool drvd = false) {
                                                         ^
c.cpp:10:14: error: after previous specification in ‘void DudeWithStats::setStats(int*, bool)’ [-fpermissive]
     void setStats(int* stats, bool derived = false);
          ^

The default parameter is given once and only once, remove it from the definition and you'll be fine.

c.cpp: In member function ‘void DudeWithStats::setStats(int*, bool)’:
c.cpp:23:23: error: incompatible types in assignment of ‘int*’ to ‘int [5]’
         derived.stats = sts;
                       ^
c.cpp:25:20: error: incompatible types in assignment of ‘int*’ to ‘int [8]’
         base.stats = sts;
                    ^

Who did said you arrays are assignable? There's memcpy and new(&base.stats) for some reason, no?

c.cpp: In function ‘int main()’:
c.cpp:34:13: error: request for member ‘setStats’ in ‘example’, which is of non-class type ‘DudeWithStats()’
     example.setStats(arrBase);
             ^
c.cpp:35:13: error: request for member ‘setStats’ in ‘example’, which is of non-class type ‘DudeWithStats()’
     example.setStats(arrDerived, true);

........

Tutorials have lied you! You're not declaring a variable, but a function!

There's an ambiguity in C++ syntax (at least from the programmer's perspective) that makes things like DudeWithStats example(); to mean "declare a function (defined somewhere else) that takes no arguments, and returns a DudeWithStats" rather than "declare a DudeWithStats named example and default-initialize it".

For the later purposes, use DudeWithStats example; (with no parentheses!). And, for brave and standards-compliant souls, C++11 supports this non-ambiguous alternative syntax found in DudeWithStats example{};. This syntax does avoid the ambiguity presented above, and it provide several other advantages, including the resolution of the (even more) confuzzling most vexing parse problem.

So the answer is...

Apart from those minor details, your code and use of templates is (syntactically) correct. P.D: May you use size_t instead of unsigned const int for everyone's mental health, please?