char value[200];
        for(int i=0;i<sizeof(value);i++)
        {
             value[i]='A';
        }

Beim Vector würde ich das so machen aber beim Array geht das ja nicht:

vector<char>var(200,'A');

std::fill(&value[0],&value[sizeof(value)-1],'A');

std::fill(&value[0],&value[sizeof(value)-1],'A');

Oder in dem konkreten Beispiel (vielleicht noch ein klein wenig leserlicher):

std::fill(std::begin(value), std::end(value), 'A');

std::array<char,200> value;
value.fill( 'A' );

std::fill(&value[0],&value[sizeof(value)-1],'A');

std::fill(value, value + sizeof(value), 'A');

Mit c++-11 geht auch das:

std::array<char,200> value;
value.fill( 'A' );

Ja, aber er möchte ein echtes Array, keinen Container.

std::fill?

std::fill(&value[0],&value[sizeof(value)-1],'A');

Warum lässt du das letzte Element aus?

Sone schrieb:

manni66 schrieb:

Mit c++-11 geht auch das:

std::array<char,200> value;
value.fill( 'A' );

Ja, aber er möchte ein echtes Array, keinen Container.

Wer hat das gesagt?
Vielleicht wusste er nicht, dass er std::array möchte. Er wusste ja auch nicht, wie man ein Array befüllt.

Sone schrieb:

std::fill(&value[0],&value[sizeof(value)-1],'A');

std::fill(value, value + sizeof(value), 'A');

Beides ist Mist, denn bei einer Änderung des Elementtyps ist sizeof(value) wahrscheinlich nicht mehr zufällig die Array-Länge.

#include <array>
#include <cstddef>

template <char... c> struct xlist {};
template <std::size_t N, typename = xlist<>> struct make_xlist;
template <std::size_t N, char... i> struct make_xlist<N, xlist<i...>>
    : make_xlist<N-1, xlist<'\0', i...>> {};
template <char... i> struct make_xlist<0, xlist<i...>>
{
    typedef xlist<i...> type;
};

template <typename T, std::size_t N, char... i>
std::array<T, N> make_array_(const T& v, xlist<i...>)
{
    std::array<T, N> r = { ( (void)i, v )... };
    return r;
}

template <typename T, std::size_t N>
std::array<T, N> make_array(const T& v = T())
{
    return make_array_<T, N>( v, typename make_xlist<N>::type() );
}

std::array<char,200> value = make_array<char, 200>( 'A' );

noch zum Spass:

std::array<char,200> value = make_array<char, 200>( 'A' );

Ich muss doch stark bitten.

template <std::size_t N, typename T> //argument deduction erlauben
std::array<T, N> make_array(const T& v = T())
{
    return make_array_<T, N>( v, typename make_xlist<N>::type() );
}

auto value = make_array<5>( 'A' ); //2x type/argument decution nutzen ;)

Warum nicht direkt das Array returnen?

Geht nicht standardkonform (korrekte Klammerung unspezifiziert). Deshalb wird es leider auch nichts mit constexpr.