constexpr, arrays and initialization

Question

Is there anything in the world of C++ that would make what I'm trying to do possible?

template < typename T
         , size_t Size >
struct array
{
    constexpr T buf[Size];

    constexpr size_t size() const { return Size; }
};

template < typename T
         , size_t Size >
constexpr array<T,Size+1> push_back(array<T,Size> const& arr, T const& val)
{
    array<T,Size+1> arr_out = {{arr.buf, val}};

    return arr_out;
}

What I'm trying to do is create a new array initialized with the data in the other, and put a new element on the end.

Minus the constexpr I can get it to work by loop initializing in the push_back function. It appears you can't do that in constexpr functions, which makes some sense though I think a smart enough compiler could figure that out.

I'm pretty sure it can't be done, but I'd love to be shown wrong.

modulo my possible misunderstanding of what you want, you can do it with varidic templates and initializer list. there is a duplicate somewhere on SO. it would not surprise if answer to that duplicate was provided by johannes schaub-lib. — Cheers and hth. - Alf
– Cheers and hth. - Alf, Commented Feb 24, 2013 at 0:54

Xeo · Accepted Answer · 2013-02-24 01:25:19Z

4

Indices trick, yay~

template < typename T
         , size_t Size >
struct array
{
    T buf[Size]; // non-static data members can't be constexpr

    constexpr size_t size() const { return Size; }
};

namespace detail{
template< typename T, size_t N, size_t... Is>
constexpr array<T, N+1> push_back(array<T, N> const& arr, T const& val, indices<Is...>)
{
    // can only do single return statement in constexpr
    return {{arr.buf[Is]..., val}};
}
} // detail::

template < typename T, size_t Size >
constexpr array<T,Size+1> push_back(array<T,Size> const& arr, T const& val)
{
    return detail::push_back(arr, val, build_indices<Size>{});
}

Live example.

answered Feb 24, 2013 at 1:25

Xeo

132k55 gold badges299 silver badges406 bronze badges

Sign up to request clarification or add additional context in comments.

4 Comments

Edward Strange Over a year ago

Have to leave for a dinner, but will check this out. If it works it's miles better than what I came up with. Thanks.

Mankarse Over a year ago

Beat me to it :P. Interestingly, this can't be implemented for std::array, because std::array does not expose constexpr accessors.

Xeo Over a year ago

@Mankarse: I think that will be taken care of for C++Next, tagging many many things in the stdlib with constexpr.

Edward Strange Over a year ago

After looking over the wiki I'm disappointed that I'm not mentioned in the Ministry of Shame.

Mankarse · Accepted Answer · 2013-02-24 03:36:02Z

1

Expanding on Xeo's answer, here is a version which forwards its arguments:

#include <boost/mpl/if.hpp>
#include <cstddef>
#include <utility>
#include <iostream>

template<typename T, std::size_t Size>
struct array
{
    typedef T value_type;
    T buf[Size];

    constexpr std::size_t size() const { return Size; }
};

template<typename T>
struct array_size;

template<typename T, std::size_t Size>
struct array_size<array<T, Size>> {
    static constexpr std::size_t value = Size;
};

template <typename T>
using Bare =
    typename std::remove_cv<typename std::remove_reference<T>::type>::type;

template <typename T>
constexpr T&& forward(typename std::remove_reference<T>::type& t) noexcept {
    return static_cast<T&&>(t);
}

template<typename Array>
using CVValueType = typename boost::mpl::if_<
    std::is_const<Array>,
    typename boost::mpl::if_<
        std::is_volatile<Array>,
        typename Array::value_type const volatile,
        typename Array::value_type const>::type,
    typename boost::mpl::if_<
        std::is_volatile<Array>,
        typename Array::value_type volatile,
        typename Array::value_type>::type
>::type;

template<typename Array>
using ForwardType =
    typename boost::mpl::if_c<
        std::is_lvalue_reference<Array>::value,
        CVValueType<typename std::remove_reference<Array>::type>&,
        CVValueType<typename std::remove_reference<Array>::type>&&>::type;

template <typename Array>
constexpr ForwardType<Array> forward_element(
    CVValueType<typename std::remove_reference<Array>::type>& t) noexcept
{
    return static_cast<ForwardType<Array>>(t);
}

template <std::size_t... Is>
struct indices {};

template <std::size_t N, std::size_t... Is>
struct build_indices
  : build_indices<N-1, N-1, Is...> {};

template <std::size_t... Is>
struct build_indices<0, Is...> : indices<Is...> {};

template<typename Array>
using Enlarged =
    array<typename Bare<Array>::value_type, array_size<Bare<Array>>::value+1>;

template<typename Array, typename T, std::size_t... Is>
constexpr Enlarged<Array> push_back(Array&& arr, T&& val, indices<Is...>)
{
    return {{forward_element<Array>(arr.buf[Is])..., forward<T>(val)}};
}

template <typename Array, typename T>
constexpr Enlarged<Array> push_back(Array&& arr, T&& val)
{
    return push_back(
        forward<Array>(arr),
        forward<T>(val),
        build_indices<array_size<Bare<Array>>::value>{});
}

answered Feb 24, 2013 at 3:36

Mankarse

40.9k12 gold badges105 silver badges146 bronze badges

2 Comments

Edward Strange Over a year ago

Does the combination of constexpr, rval referenecs, forwarding, and move semantics make sense? What happens when you move a constant? I'd imagine that it kills the constexpr aspect?

Quuxplusone Over a year ago

@CrazyEddie Nope, any constructor can be constexpr, even a move constructor. Obviously you can't do anything side-effecting inside the constructor (such as changing the contents of the rvalue-reference argument), but you can do all the same stuff you'd do in a constexpr copy constructor, member function, or whatever.

Edward Strange · Accepted Answer · 2013-02-24 01:33:51Z

namespace detail_
{

template < typename T
         , size_t End >
struct push_backer
{
    template < typename Array
             , typename ... Args>
    static constexpr auto push_back(Array const& arr, Args const& ... args) -> decltype(push_backer<T,End-1>::push_back(arr, arr.buf[End-1],args...))
    {
        return push_backer<T,End-1>::push_back(arr, arr.buf[End-1], args...);
    }
};

template < typename T >
struct push_backer<T,0>
{
    template < size_t Size
             , typename ... Args>
    static constexpr array<T,Size+1> push_back(array<T,Size> const& arr, Args const& ... args)
    {
        return array<T,Size+1>{{args...}};
    }
};

}

template < typename T
         , size_t Size >
constexpr array<T,Size+1> push_back(array<T,Size> const& arr, T const& val)
{
    return detail_::push_backer<T,Size>::push_back(arr, val);
}

Collectives™ on Stack Overflow

constexpr, arrays and initialization

3 Answers 3

4 Comments

2 Comments

Comments

Your Answer

Linked

Hot Network Questions

Collectives™ on Stack Overflow

3 Answers 3

4 Comments

2 Comments

Comments

Your Answer

Sign up or log in

Post as a guest

Linked

Related