arrays — использовать указатель члена структуры для заполнения структуры в переполнении стека

Вариантное решение на основе шаблонов:

struct my_struct_t {
char one_field[30];
char another_field[40];
};

template<typename T1, typename T2>
void do_mapping(T1& a, T2& b) {
std::cout << sizeof(b) << std::endl;
strncpy(b, a, sizeof(b));
}

template<typename T1, typename T2, typename... Args>
void do_mapping(T1& a, T2& b, Args&... args) {
do_mapping(a, b);
do_mapping(args...);
}

int main()
{
my_struct_t ms;
do_mapping(
"FIRST_MAPPING",  ms.one_field,
"SECOND_MAPPING", ms.another_field
);
return 0;
}

поскольку data_t это структура POD, вы можете использовать offsetof() за это.

const std::vector<std::pair<const char *, std::size_t>> mapping = {
{ "FIRST_FIELD" , offsetof(data_t, field1},
{ "SECOND_FIELD", offsetof(data_t, field2)}
};

Тогда цикл будет:

for (auto const& it : mapping) {
strcpy(static_cast<char*>(&data) + it.second, getData(it.first));
}

Я не думаю, что есть какой-то способ подобрать размер члена. Вы можете вычесть смещение текущего члена из следующего, но это будет включать байты заполнения. Вы также должны были бы в специальном случае последний член вычесть смещение из размера самой структуры, так как нет следующего члена.

Отображение может быть функцией записи данных в соответствующий элемент

struct mapping_t
{
const char * name;
std::function<void(my_struct_t *, const char *)> write;
};

const std::vector<mapping_t> mapping = {
{ "FIRST_KEY",  [](data_t & data, const char * str) { strlcpy(data.field1, str, sizeof(data.field1); } }
{ "SECOND_KEY", [](data_t & data, const char * str) { strlcpy(data.field2, str, sizeof(data.field2); } },
{ "THIRD_KEY",  [](data_t & data, const char * str) { strlcpy(data.field3, str, sizeof(data.field3); } },
};

int main()
{
data_t data;

for (auto const& it : mapping) {
it.write(data, getData(it.name));
}
}

Чтобы перебрать член структуры, вам нужно:

1. смещение / указатель на начало этого члена
2. размер этого члена

struct Map {
const char *key;
std::size_t offset;
std::size_t size;
};

std::vector<Map> map = {
{ field_keys[0], offsetof(data_t, field1), sizeof(data_t::field1), },
{ field_keys[1], offsetof(data_t, field2), sizeof(data_t::field2), },
{ field_keys[2], offsetof(data_t, field3), sizeof(data_t::field3), },
};

когда у нас есть то, что нам нужно strlcpy:

std::size_t mystrlcpy(char *to, const char *from, std::size_t max)
{

char * const to0 = to;
if (max == 0)
return 0;
while (--max != 0 && *from) {
*to++ = *from++;
}
*to = '\0';
return to0 - to - 1;
}

После этого мы можем просто:

data_t data;

for (auto const& it : map) {
mystrlcpy(reinterpret_cast<char*>(&data) + it.offset, getData(it.key), it.size);
}

Тот reinterpret_cast выглядит немного некрасиво, но это просто сдвиг &data указатель на нужное поле.

Мы также можем создать более умный контейнер, который принимает указатель на переменную при построении, таким образом, связывается с существующей переменной и требует небольшой записи:

struct Map2 {
static constexpr std::size_t max = sizeof(field_keys)/sizeof(*field_keys);

Map2(data_t* pnt) : mpnt(pnt) {}

char* getDest(std::size_t num) {
std::array<char*, max> arr = {
mpnt->field1,
mpnt->field2,
mpnt->field3,
};
return arr[num];
}

const char* getKey(std::size_t num) {
return field_keys[num];
}

std::size_t getSize(std::size_t num) {
std::array<std::size_t, max> arr = {
sizeof(mpnt->field1),
sizeof(mpnt->field2),
sizeof(mpnt->field3),
};
return arr[num];
}

private:
data_t* mpnt;
};

Но, вероятно, делает итерацию более читабельной:

Map2 m(&data);
for (std::size_t i = 0; i < m.max; ++i) {
mystrlcpy(m.getDest(i), getData(m.getKey(i)), m.getSize(i));
}

Живой код доступен на onlinegdb.