Variadic Template not working expectetly

[LukeProducts]

Dear Community,

i cannot figure out how to solve this. I am coding a Container Class and run into a Problem with my constructor. I wanna take a variadic list of arguments of the specified type and add them to my array like f.ex. std::vector can do, but this does not work. Why and how to fix that?

my code:

#include <iostream>

template <typename VTYPE>


class ContainerList{
    VTYPE* _data = nullptr;
    size_t size{};


public:

    VTYPE* begin() {return _data;}
    VTYPE* end() {return _data + size;}
    void push_back(VTYPE elem) {
        if (_data == nullptr)
        {
            VTYPE *_copy = new VTYPE[size = 1]{};
            _copy[size - 1] = elem;
            _data = _copy;

        } else
        {
            VTYPE *_copy = new VTYPE[++size]{};
            std::copy(_data, _data + size, _copy);
            _copy[size - 1] = elem;
            delete[] _data;
            _data = _copy;

        }
    }
    
    ContainerList() = default;



    // this part is not working
    template<typename ...VTLST>
    ContainerList(VTLST... arg) { push_back(arg...);}
    // VTLST showld only take values of type VTYPE



    VTYPE operator[](size_t ind) {return _data[ind];}
    ~ContainerList() {delete[] _data;}
};

usage:

ContainerList<int> hello{12, 41, 55};

[runtime does not matter]

Any advices?

nice greetings

Luke

[Cubbi]

it's not just "not working", it's saying exactly what's wrong:

no matching function for call to 'ContainerList<int>::push_back(int&, int&, int&)'
note: candidate: 'void ContainerList<VTYPE>::push_back(VTYPE) [with VTYPE = int]'
note:  candidate expects 1 argument, 3 provided

There are many other things to fix in this code, but the minimal fix for this error message is to re-write line 39 so it calls the 1-argument push_back 3 times, rather than non-existent 3-argument push_back 1 time
ContainerList(VTLST... arg) { (push_back(arg), ...);}

[LukeProducts]

Thank you very much

[seeplus]

Why not use an initializer_list?

#include <iostream>
#include <initializer_list>

template <typename VTYPE>
class ContainerList {
	VTYPE* _data {};
	size_t size {};

public:
	VTYPE* begin() const { return _data; }
	VTYPE* end() const { return _data + size; }

	void push_back(const VTYPE& elem) {
		if (_data == nullptr)
			_data = new VTYPE[size = 1] {elem};
		else {
			auto* _copy { new VTYPE[++size] {} };

			std::copy(_data, _data + size, _copy);
			_copy[size - 1] = elem;
			delete[] _data;
			_data = _copy;
		}
	}

	ContainerList() = default;
	ContainerList(const VTYPE& i) : size(1), _data(new VTYPE[1] {i}) {}

	ContainerList(std::initializer_list<VTYPE> il) {
		for (const auto& i : il)
			push_back(i);
	}

	VTYPE operator[](size_t ind) { return _data[ind]; }
	const VTYPE operator[](size_t ind) const {return _data[ind]; }

	~ContainerList() {
		delete[] _data;
	}

	ContainerList(const ContainerList&) = delete;
	ContainerList& operator=(const ContainerList&) = delete;
};

int main() {
	ContainerList<int> hello { 12, 41, 55 };

	for (auto i { hello.begin() }; i != hello.end(); ++i)
		std::cout << *i << "  ";

	std::cout << '\n';

	ContainerList<int> h1(34);

	std::cout << h1[0] << '\n';

	h1.push_back(99);
	h1.push_back(66);

	for (auto i { h1.begin() }; i != h1.end(); ++i)
		std::cout << *i << "  ";

	std::cout << '\n';

}

[TheIdeasMan]

Hi,

To have a proper RAII class, ensure in the destructor that you delete all the things you made with new . At the moment you run the risk of memory leakage when faced with an exception.
https://en.cppreference.com/w/cpp/language/raii

Use std::size_t , not a naked size_t.

If you have begin() and end() defined, or the object is an array, and you wish to iterate the whole container, you can use a range based for loop.

Rule of 0,3,5 : https://en.cppreference.com/w/cpp/language/rule_of_three

Consider using noexcept
https://en.cppreference.com/w/cpp/language/noexcept
https://en.cppreference.com/w/cpp/language/noexcept_spec


Edit:

Oh and [[nodiscard]] (C++17) for functions that return something:
https://en.cppreference.com/w/cpp/language/attributes

[seeplus]

I wanna take a variadic list of arguments of the specified type

Using templates, then consider:

template<typename... Ts>
using AllSame = std::enable_if_t<std::conjunction_v<std::is_same<VTYPE, Ts>...>>;

template<typename... Ts, typename = AllSame<Ts...>>
ContainerList(Ts... arg) {
	(push_back(arg), ...);
}

ContainerList<int> hello { 12, 76};    // OK
//ContainerList<int> hello { 12.1, 76};    // Bad
ContainerList<double> hello { 12.1, 76.0};    // OK 

[JLBorges]

C++20:

#include <concepts>

template < typename VTYPE > struct ContainerList
{
    // if: every constructor argument must be of a type convertible to VTYPE
    template < std::convertible_to<VTYPE>... T > ContainerList( T&&... args )
    { ( ( push_back( std::forward<T>(args) ) ), ... ) ; }

    // or if: every constructor argument must be of type VTYPE
    // template < std::same_as<VTYPE>... T > ContainerList( T&&... args )
    // { ( ( push_back( std::forward<T>(args) ) ), ... ) ; }

    void push_back( const VTYPE& ) { /* ... */ } // copy construct at the back
    void push_back( VTYPE&& ) { /* ... */ } // move construct at the back
    
    // ... 
};