结构体数组所有元素（1亿个元素）初始化为相同的值

一个结构体数组，有1亿个元素，每个元素都要初始化为相同的值，如果没有现成的语法直接支持这样的初始化操作，就得用for循环写，会不会非常耗时？

如果结构体里的成员都是一些简单的基本数据类型，整个结构体才几十个字节，即使有1亿个元素，用for循环赋值，程序执行时间也只要10^8纳秒级别，0.1秒的样子。编译器优化+高速缓存命中，速度已经飞快了，不用操心那么多。循环展开这些优化方法，编译器优化都可能帮你做了，手动优化代码可能基本没效果（1e8+5即1亿零5个元素，多出5个零头是为了回头测试多线程对不对）

#include 
using namespace std;

struct Test
{
	char a;
	int b;
	float c;
};

int main()
{
	clock_t t1 = clock();

	const int data_num = 1e8 + 5;
	Test* array = new Test[data_num];
	if (array == NULL)
	{
		cout << "memory alloc error" << endl;
		return -1;
	}

	array[0].a = 'a';
	array[0].b = 123;
	array[0].c = 123.45;

	for (int i = 1; i < data_num; i++)
	{
		array[i] = array[0];
	}

	cout << array[data_num - 1].a << endl;
	cout << array[data_num - 1].b << endl;
	cout << array[data_num - 1].c << endl;

	clock_t t2 = clock();
	cout << t2 - t1 << "毫秒" << endl;

	return 0;
}

下面使用多线程，而且每个线程使用翻倍memcpy（按1、2、4、8……翻倍进行copy）

#include 
#include 
using namespace std;

struct Test
{
	char a;
	int b;
	float c;
};

const int data_num = 1e8 + 5;
const int thread_num = 4;

void memcpy_thread(Test* array, int tid)
{
	int base_pos = data_num / thread_num * tid;
	int cur_pos = 1;
	while (cur_pos * 2 <= data_num / thread_num)
	{
		memcpy_s(array + base_pos + cur_pos, sizeof(Test) * cur_pos, array + base_pos, sizeof(Test) * cur_pos);
		cur_pos *= 2;
	}
	memcpy_s(array + base_pos + cur_pos, sizeof(Test) * (data_num / thread_num - cur_pos), array + base_pos, sizeof(Test) * (data_num / thread_num - cur_pos));
}

int main()
{
	clock_t t1 = clock();

	Test* array = new Test[data_num];
	if (array == NULL)
	{
		cout << "memory alloc error" << endl;
		return -1;
	}

	for (int i = 0; i < thread_num; i++)
	{
		int index = data_num / thread_num * i;
		array[index].a = 'a';
		array[index].b = 123;
		array[index].c = 123.45;
	}

	thread td[thread_num];
	for (int i = 0; i < thread_num; i++)
	{
		td[i] = thread(&memcpy_thread, array, i);
	}

	for (int i = 0; i < thread_num; i++)
	{
		td[i].join();
	}

	for (int i = data_num / thread_num * thread_num; i < data_num; i++)
	{
		array[i].a = 'a';
		array[i].b = 123;
		array[i].c = 123.45;
	}

	cout << array[data_num - 1].a << endl;
	cout << array[data_num - 1].b << endl;
	cout << array[data_num - 1].c << endl;

	clock_t t2 = clock();
	cout << t2 - t1 << "毫秒" << endl;

	return 0;
}

1亿零5个元素（多出5个零头是为了测试多线程对不对），多线程+翻倍memcpy，用时大概70毫秒。之前直接用for循环，用时大概150毫秒，多线程和翻倍memcpy的加速效果似乎都不明显。多线程加速效果不明显，3个线程以上基本没有加速效果了，猜测是硬件资源的并行度有限（这样说可能不准确），可能是竞争之类的原因导致的，或者是因为总线宽度有限？