C++ Error: Cannot initialize an array element of type 'char' with an lvalue of type 'char [1024]' - c++

Question

First I convert my string to type char
//Convert string to char
string temp = "TFTFTFTFTFFFTTFFTTFFTTTTTTFFFF";
string temp = line;
char tab2[1024];
strcpy(tab2, temp.c_str());
cout << "The value of the string conversion is: " << tab2 <<endl;
Then I attempt to assign the tab2 contents to the char array:
char Array[] = {tab2};
Error: Cannot initialize an array element of type 'char' with an lvalue of type 'char [1024]

Answer 1

What happens in your case is that you are trying to initialize a c-style array with another c-style array.
C-style arrays can't be initialized in this manner nor can they be copied using a regular copy assignment.
To copy it using the copy assignment would require looping through and copying one element at a time and actually assigning a size to the second array.
There are two more practical approaches for your problem.
Either use std::array<> or another container type, instead of a char array, or use memcpy
For the former approach you'll just have to replace your arrays to type std::array<> and then you can initialize or copy with the regular copy assignment as you like.
For the latter approach you can use memcpy() to copy the memoryblock from the first c-style array to the other. Like this:
Read these reference pages on memcpy:
http://www.cplusplus.com/reference/cstring/memcpy
https://en.cppreference.com/w/cpp/string/byte/memcpy
{
/* ... */
char new_tab[1024] = {0};
std::memcpy(new_tab, prev_tab, sizeof(char)*1024);
std::cout << "The value after copy is: " << new_tab << std::endl;
/* ... */
}
Edit:
As your intent with this was not clear, but lets assume it is an assignment and you have to convert to an array and then copy the array to another array.
In that case read this for reference:
https://en.cppreference.com/w/cpp/string/byte/strncpy
http://www.cplusplus.com/reference/cstring/strncpy/
And then keep things as you had them but just change your char Array[] = {tab2};
To:
{
/* ... */
char new_tab[1024];
// Copies 1024 characters from prev_tab to new_tab
std::strncpy(new_tab, prev_tab, 1024);
/* ... */
}
Note: Also edited and added some reference links

Answer 2

You cannot do
char Array[] = {tab2};
because that expects expression tab2 to be bound to an element of array as per initialization list syntax. You cannot do
char Array[] = tab2;
either , because name of array tab2 decays to a pointer to its first element. Very same problem exists in C and it can be solved in same ways. Either copy them element by element, use memcpy or strcpy or C++ idiomatic std::copy, or use array as part on aggregate. But C++ got an aggregate you can use in <array>:
std::array<char,1024> tab2;
// we really have to check length there, you can overflow this buffer
strcpy(tab2.data(), temp.c_str());
auto Array = tab2;
A struct that allow a shallow copy will do too:
struct S {
char _data[1024];
char* data() { return _data; }
};
Shallow copy performed on S or on std::array copies storage of every element
of source to destination. This cannot be used with pointers because the pointer will be copied, not the storage it is pointing at.
That's essentially a model of std::array<char,1024> minus its bells and whistles.