C++ wrapper class to mimic a C array's brace initialization

Question

I have an inheritance class that mimics the behavior of C style array's brace initialization by using a class template that has a variadic constructor but the template itself is not a variadic template. The base class stores the contents from two flavors of constructors either a Variadic Constructor, or a Variadic Constructor that takes an std::initializer_list as it's parameter. The base class also contains a size that is inferred by its populated member vector, a function to return its size and an overloaded operator operator()() that will return its internal vector.

The child class inherits this functionality. It only has one member and that is a pointer to <T>. It has the corresponding matching constructors as its parent class, a set of overloaded subscript-indexing operators and a public method to retrieve it's internal pointer. This class's internal pointer is set to point to its parent's internal vector's data.

As far as I can tell this appears to be bug free to the best of my knowledge and it is producing expected values. Here is what I have so far.

---

#include <vector>
#include <string>
#include <sstream>
#include <iostream>
#include <exception>
#include <type_traits>
#include <initializer_list>
#include <utility>

template<typename T>
class ParamPack {
protected:
    std::vector<T> values_;
    size_t size_;
public:
    template<typename... U>
    ParamPack( U... u ) : values_{ static_cast<T>(u)... } {
        size_ = values_.size();
    }

    template<typename ... U>
    ParamPack( std::initializer_list<std::is_same<T, U...>( U...)> il ) : values_( il ) {
        size_ = values_.size();
    }

    std::vector<T> operator()() {
        return values_;
    }

    const size_t size() const { return size_; }
};

template<typename T>
class Array : public ParamPack<T> {
private:
    T* items_;
public:

    template<typename... U>
    Array( U... u ) : ParamPack<T>::ParamPack( u... ) {
        items_ =  this->values_.data();
    }

    template<typename... U>
    Array( std::initializer_list<U...> il ) : ParamPack<T>::ParamPack( il ) {
        items_ = this->values_.data();
    }

    T& operator[]( int idx ) {
        return items_[idx];
    }

    T operator[]( int idx ) const {
        return items_[idx];
    }

    T* data() const { return items_; }

};

int main() {
    try {
        // Parameter Pack Examples:
        // Variadic Constructor { ... }
        std::cout << "ParamPack<T> Examples:\n";
        std::cout << "Using ParamPack<T>'s Variadic Constructor\n";
        ParamPack<int> pp1( 1, 2, 3, 4  );
        std::cout << "Size: " << pp1.size() << " | Elements: ";
        for( auto& v : pp1() ) {
            std::cout << v << " ";
        }
        std::cout << '\n';      
        //std::initializer_list<int> il{ 1,2,3,4 };
        std::cout << "Using ParamPack<T>'s Initializer List\n";
        ParamPack<int> pp2( { 5, 6, 7, 8 } );
        std::cout << "Size: " << pp2.size() << " | Elements: ";
        for( auto& v : pp2() ) {
            std::cout << v << " ";
        }
        std::cout << "\n\n";

        // Array Examples:
        // Using  Variadic Constructor
        std::cout << "Array<T> Examples:\n";
        std::cout << "Using Array<T>'s Variadic Constructor\n";
        Array<int> testA( 9, 8, 7, 6 );
        for( size_t i = 0; i < testA.size(); i++ ) {
            std::cout << testA[i] << " ";
        }
        std::cout << '\n';

        Array<std::string> testB( "Hello", " World" );
        for( size_t i = 0; i < testB.size(); i++ ) {
            std::cout << testB[i] << " ";
        }
        std::cout << "\n\n";

        // Using Constructor w/ Initializer List
        std::cout << "Using Array<T>'s Constructor with Initializer List\n";
        Array<int> testC( { 105, 210, 420 } );
        for( size_t i = 0; i < testC.size(); i++ ) {
            std::cout << testC[i] << " ";
        }
        std::cout << "\n\n";

        // Using Initializer List with =
        std::cout << "Using Array<T>'s Initializer List with =\n";
        Array<int> a = { 1, 2, 3, 4 };
        for( size_t i = 0; i < a.size(); i++ ) {
            std::cout << a[i] << " ";
        }
        std::cout << '\n';                

        Array<char> b = { 'a', 'b', 'c', 'd' };
        for ( size_t i = 0; i < b.size(); i++ ) {
            std::cout << b[i] << " ";
        }
        std::cout << '\n';

        Array<double> c = { 1.2, 3.4, 4.5, 6.7 };
        for( size_t i = 0; i < c.size(); i++ ) {
            std::cout << c[i] << " ";
        }
        std::cout << "\n\n"; 

        // Using Initializer List directly
        std::cout << "Using Array<T>'s Initalizer List directly\n";
        Array<uint32_t> a1{ 3, 6, 9, 12 };
        for( size_t i = 0; i < a1.size(); i++ ) {
            std::cout << a1[i] << " ";
        }
        std::cout << "\n\n";

        // Using user defined data type
        struct Point {
            int x_, y_;
            Point( int x, int y ) : x_( x ), y_( y ) {}
        };
        Point p1( 1, 2 ), p2( 3, 4 ), p3( 5, 6 );

        // Variadic Constructor
        std::cout << "Using Array<T>'s Variadic Consturctor with user data type\n";
        Array<Point> d1( p1, p2, p3 );
        for( size_t i = 0; i < d1.size(); i++ ) {
            std::cout << "(" << d1[i].x_ << "," << d1[i].y_ << ") ";
        }
        std::cout << '\n';

        // Initializer List Construtor (reversed order)
        std::cout << "Using Array<T>'s Initializer List Constructor with user data type\n";
        Array<Point> d2( { p3, p2, p1 } );
        for( size_t i = 0; i < d2.size(); i++ ) {
            std::cout << "(" << d2[i].x_ << "," << d2[i].y_ << ") ";
        }
        std::cout << '\n';

        // Initializer List Version = {...} p2 first
        std::cout << "Using Array<T>'s  = Initializer List with user data type\n";
        Array<Point> d3 = { p2, p1, p3 };
        for( size_t i = 0; i < d3.size(); i++ ) {
            std::cout << "(" << d3[i].x_ << "," << d3[i].y_ << ") ";
        }
        std::cout << '\n';

        // Initializer List Directly p2 first p1 & p3 swapped
        std::cout << "Using Array<T>'s Initializer List directly with user data type\n";
        Array<Point> d4{ p2, p3, p1 };
        for( size_t i = 0; i < d4.size(); i++ ) {
            std::cout << "(" << d4[i].x_ << "," << d4[i].y_ << ") ";
        }
        std::cout << "\n\n";        

        // Need a local copy of the vector instead?
        std::cout << "Using Array<T>'s base class's operator()() to retrieve vector\n";
        std::vector<Point> points = d4(); // using operator()()
        for( auto& p : points ) {
            std::cout << "(" << p.x_ << "," << p.y_ << ") ";
        }
        std::cout << '\n';

        // Need a local copy of the pointer instead?
        std::cout << "Using Array<T>'s data() to get the contents of its internal pointer\n";
        Point* pPoint = nullptr;
        pPoint = d4.data();
        for( size_t i = 0; i < d4.size(); i++ ) {
            std::cout << "(" << pPoint[i].x_ << "," << pPoint[i].y_ << ") ";
        }
        std::cout << '\n';

        // Will Not Compile: Must Be Instantiated By Type Explicitly
        // Array e( 1, 2, 3, 4 );
        // Array e( { 1,2,3,4 } );
        // Array f{ 1, 2, 3, 4 };
        // Array g = { 1,2,3,4 };    

    } catch( const std::runtime_error& e ) {
        std::cerr << e.what() << '\n';
        return EXIT_FAILURE;
    }

    return EXIT_SUCCESS;
}

---

-Output-

ParamPack<T> Examples:
Using ParamPack<T>'s Variadic Constructor
Size: 4 | Elements: 1 2 3 4
Using ParamPack<T>'s Initializer List
Size: 5 | Elements: 5 6 7 8 

Array<T> Examples:
Using Array<T>'s Variadic Constructor
9 8 7 6
Hello World

Using Array<T>'s Constructor with Initializer List
105 210 420

Using Array<T>'s Initializer List with =
1 2 3 4
a b c d
1.2 3.4 5.6 7.8

Using Array<T>'s Initializer List directly
3 6 9 12

Using Array<T>'s Variadic Constructor with user data type
(1,2) (3,4) (5,6)
Using Array<T>'s Initializer List Constructor with user data type
(5,6) (3,4) (1,2)
Using Array<T>'s = Initializer List with user data type
(3,4) (1,2) (5,6)
Using Array<T>'s Initializer List directly with user data type
(3,4) (5,6) (1,2)

Using Array<T>'s base class's operator()() to retrieve vector
(3,4) (5,6) (1,2)   
Using Array<T>'s data() to get the contents of its internal pointer
(3,4) (5,6) (1,2)     

---

There are few things I'd like to know about this code: The main concerns are more towards the classes themselves than the actual code use within the main function. However, suggestions towards the use of the class are accepted as well.

• Does this follow modern best practices? Note: I know I can encapsulate it in an namespace but for simplicity I just posted the classes themselves
  • If not what changes or fixes need to be made?
• Is it considered readable enough?
• Is the code efficient?
  • What can be done to improve its efficiency?
• Are there any unforeseen bugs or gotchas that I overlooked?
• Is this considered portable, reusable, and generic?
• Will the derived class invoke the appropriate constructor or will it just fall back to one of them?

Answer 1

• I think you should make your interface constexpr
• Did you expect negative index? If not, try to use std::size_t instead of int.
• Does returning values_ by value is a design choice?
• You specify the return type of size () as const size_t but the const is useless here.
• Try to avoid static_cast when you can.
• To initialize list_, you can use sizeof... () instead of calling size () method, and adding it at the end of the member initializer lists.
• Since your parameter pack is know at compile time, have you tried to use std::array instead of std::vector. ( and look at his interface, for a good example of const-correctness.)

Answer 2

#include <vector>
#include <string>
#include <sstream>
#include <iostream>
#include <exception>
#include <type_traits>
#include <initializer_list>
#include <utility>

Do the following:

1. Split your test code from your library code.
2. Organize your headers so it's easier to find if a header has been included.
3. Remove headers that are not used. (<sstream>, <exception>)

---

template<typename T>
class ParamPack {
protected:
    std::vector<T> values_;
    size_t size_;

Using std::vector introduces two problems:

1. Allocation
   • Data is on the heap instead of the stack.
   • You discarded the size, which is known at compile time, just to be able to derive the size later.
2. Object Size
   • You are storing
     • the data on the heap,
     • a pointer in Array to the data,
     • three pointers in std::vector<> to the data, and
     • the size of the std::vector<>.
   • A std::array<> would simply store the data on the stack.

---

public:
    template<typename... U>
    ParamPack( U... u ) : values_{ static_cast<T>(u)... } {
        size_ = values_.size();
    }

    template<typename ... U>
    ParamPack( std::initializer_list<std::is_same<T, U...>( U...)> il ) : values_( il ) {
        size_ = values_.size();
   }

    const size_t size() const { return size_; }

The constructor that takes the initializer list is never taken as substitution failure simply causes it to always be removed from the overload set. In your test code, the implicitly constructed lists are not std::initializer_list<int> types and won't take that overload.

Your arguments in the variadic are passed by value. You end up copying u in Array::Array(...), ParamPack::ParamPack(...), and std::vector<int>::std::vector<int>(std::initializer_list<int>). Read up on perfect forwarding.

Don't store size_. Just call values_.size() whenever you need the size.

Qualify size() with the [[nodiscard]] attribute.

    std::vector<T> operator()() {
        return values_;
    }

Did you intend to return by value?

---

    T operator[]( int idx ) const {
        return items_[idx];
    }

Did you intend to return by value?

You have an implicit conversion on access std::vector that changes the signedness of the index. std::vector<>::operator[] expects the index type to be std::vector::size_type, which is often std::size_t.

---

    int main() { ... }

It is great everything prints out, but are the observed results the expected results? Use a testing framework.

---

Does this follow modern best practices? Note: I know I can encapsulate it in an namespace but for simplicity I just posted the classes themselves

Namespace wrapping is definitely a starter. You should minimize the number of symbols you introduce into the global namespace.

Prefer the qualified standard types (::std::size_t) instead of the unqualified types (::size_t). The C++ Standard makes no guarantee that the unqualified symbols exist. See C++17 draft n4659 § 15.5.4.3.4/1.

Use std::array<> when the container has a fixed size known at compile-time.

If you want your container to be used as if it were a C++ container, you must fulfill the standard general container requirements.

Don't use a raw pointer (T*). Use alternative solutions. std::observer_ptr in C++20 doesn't require any special feature that would prevent it from being implemented in earlier C++ revisions. The reason for the existence of the world's dumbest smart pointer is to:

1. Self-document that the pointer is a non-owning reference to an object (not an owning-reference, built-in array, built-in string or iterator),
2. Default construct to a sane initial state (nullptr),
3. Only support reference operations (no operator[] meant for arrays/strings, no pointer arithmetic meant for pointers),
4. Strict-weak ordering guarantee, and
5. Discourages using unsafe void*.

Are there any unforeseen bugs or gotchas that I overlooked?

You should be aware of class template argument deduction guides introduced in C++17. The compiler can deduce both the size and the type from the arguments provided. Here is the deduction guide for std::array.

std::array a1{1, 2, 42};  // deduced as std::array<int, 3>
std::array a2{1, 2, 42u}; // ill-formed as types are not the same.

You can also write your own guide to derive the type while allowing the user to provide a type.