C++ how to copy contents of std::array to another?

Question

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

Answer 1

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::array s changes. Given they are statically sized, I'd throw in a static_assert(test.size() <= test2.size()); for good measure.

Answer 2

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;
    }
}

Answer 3

I can offer using the algorithm Depth first search . Without any doubts it is not rational but it performs requirements, described in the current problem.

#include <iostream>
#include <array>
#include <vector>
using namespace std;
const int maximumSize=20;
//copy test2 into test
array<char, 20> test = {"asdasd"};
array<char, 19> test2 = {"asdassdsdfd"};
vector<int> visited(maximumSize, 0);
template<typename Type>
void showContent1D(Type input)
{
    for(int i=0; i<input.size(); ++i)
    {
        cout<<input[i]<<", ";
    }
    return;
}
void depthFirstSearch(int firstIndex)
{
    if(visited[firstIndex]==1)
    {
        return;
    }
    visited[firstIndex]=1;
    test[firstIndex]=test2[firstIndex];
    for(int index=0; index<test2.size(); ++index)
    {
        depthFirstSearch(index);
    }
    return;
}
int main()
{
    cout<<"Before copying:"<<endl<<"test <- ";
    showContent1D(test);
    cout<<endl<<"test2 <- ";
    showContent1D(test2);
    cout<<endl<<"<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<"<<endl;
    depthFirstSearch(0);
    cout<<"After copying:"<<endl<<"test <- ";
    showContent1D(test);
    cout<<endl<<"test2 <- ";
    showContent1D(test2);
    return 0;
}

The output is here:

Before copying:
test <- a, s, d, a, s, d, , , , , , , , , , , , , , , 
test2 <- a, s, d, a, s, s, d, s, d, f, d, , , , , , , , , 
<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
After copying:
test <- a, s, d, a, s, s, d, s, d, f, d, , , , , , , , , , 
test2 <- a, s, d, a, s, s, d, s, d, f, d, , , , , , , , ,