Its fairly well known on how to copy a standard c array into another:

char test[20] = "asdasd";
char test2[19] = "asdassdsdfd";
strcpy_s(test, sizeof(test), test2);

But how can I do the same with a std::array? (preferably without for loops)

std::array<char, 20> test = {"asdasd"};
std::array<char, 19> test2 = {"asdassdsdfd"};
// copy test2 into test

CodePudding user response：

There are many ways. You could use strcpy_s(test.data(), sizeof(test), test2.data()), but I wouldn't recommend it. The more-generic version of basically the same thing is std::copy_n(test.begin(), test.size(), test2.begin()); which would continue to be correct even if the type in the std::arrays changes. Given they are statically sized, I'd throw in a static_assert(test.size() <= test2.size()); for good measure.

CodePudding user response：

This is a more elaborate answer to what you're trying to do. I don't really recommend using arrays to hold strings though.

#include <array>
#include <iostream>

// copy solution without loops, though probably it would have been more readable with them :)
template<typename type_t, std::size_t N1, std::size_t N2>
void copy_array(const std::array<type_t, N1>& source, std::array<type_t, N2>& destination)
{
    // copy to a larger destination 
    if constexpr (N1 <= N2)
    {
        // this will copy the whole array! not just the characters from the string literal!
        std::copy(source.begin(), source.end(), destination.begin());

        // fill remainder of destination with 0's
        auto it = destination.begin();
        std::advance(it, N1);
        std::fill(it, destination.end(), 0);
    }
    else
    // copy into a smaller array, then copy only the beginning
    // note this will also result in an array without trailing 0's
    // an array is NOT a string.
    {
        
        auto end = source.begin();
        std::advance(end, N2);
        std::copy(source.begin(), end, destination.begin());
    }
}

int main()
{
    // Note you're probably better of just using const std::strings instead of std::arrays
    // this also avoids the pain involved in copying rules for mismatching array sizes.
    // The arrays initialized with string literals smaller then their size initialize the 
    // rest of the array to 0's
    std::array<char, 20> test{ "asdasd" };
    std::array<char, 19> test2{ "asdassdsdfd" };

    copy_array(test2, test);
    
    for (const auto c : test)
    {
        std::cout << c;
    }
}