CUDA，不能为数组指定新的初始值设定项

所以我目前有这段代码，但在编译时遇到了一个错误，即"可能没有为数组指定新的初始值设定项"，但我在代码中没有声明新数组的位置。所以我不确定这个问题是在哪里以及如何发生的。这是我认为问题所在的代码部分…

struct indvPasswords
{
    int blockId;
    int threadId;
    list<char[1024]> passwords;
};
//22,500 individual blocks
int gridSize = 150;
//1024 threads contained within each block
int blockSize = 32;
int totalNumThreads = (gridSize*gridSize)*(blockSize*blockSize);
indvPasswords* pointerToPass = new indvPasswords[totalNumThreads];

这是所有的源代码。它目前使用cuda查找字典密码。。。

#include "cuda_runtime.h"
#include "device_launch_parameters.h"
#include <stdio.h>
#include <iostream>
#include <fstream>
#include <string>
#include <list>
using namespace std;
//////////////////////////////
//          Constants       //
//////////////////////////////
string password = "C:\Users\james\Desktop\password.txt";
string passwordListFile = "C:\Users\james\Desktop\10millionpasswordlist.txt";
struct indvPasswords
{
    int blockId;
    int threadId;
    list<char[1024]> passwords;
};
//22,500 individual blocks
int gridSize = 150;
//1024 threads contained within each block
int blockSize = 32;
int totalNumThreads = (gridSize*gridSize)*(blockSize*blockSize);
indvPasswords* pointerToPass = new indvPasswords[totalNumThreads];

//Some serial setup first
string passwordFile()
{
    string pwd = "";
    ifstream fileStream(password);
    if (fileStream.is_open()) {
        getline(fileStream, pwd);
        if (pwd != "") {
            //Found a password
            fileStream.close();
        }
        else {
            cout << "No password found in file" << 'n';
        }
    }
    else {
        cout << "Cannot open password file" << 'n';
    }
    return pwd;
}
list<string> readPasswordList()
{
    //open password list
    string line = "";
    ifstream fileStream(passwordListFile);
    list<string> passwordList;
    if (fileStream.is_open()) {
        while (getline(fileStream, line)) {
            passwordList.push_back(line);
        }
    }
    else {
        cout << "Cannot open password file" << 'n';
    }
    return passwordList;
}
void indexing()
{
    list<string> passwords = readPasswordList();
    int sizeOfList = passwords.size();
    int modulus = sizeOfList%gridSize;
    int runFlag = 0;
    if (modulus != 0) {
        //not evenly divided, pass overflow to first block
        //Take the modulus off the size of password list, i.e. 
        //take a number of passwords from the top of the list.
        //Temporarily store the passwords removed and give them 
        //as additional work to the first block.
        list<string> temp;
        for (int i = 0; i < modulus; i++) {
            temp.push_back(passwords.front());
            passwords.pop_front();
        }
        //Now evenly divide up the passwords amoungst the blocks
        int numEach = passwords.size();
        //The first for loop, iterates through each BLOCK within the GRID
        for (int i = 0; i < (gridSize*gridSize); i++) {
            //Set flag, for single run of first block list
            if (i == 0) {
                runFlag = 1;
            }
            //The second loop, iterates through each THREAD within the current BLOCK
            for (int j = 0; j < (blockSize*blockSize); j++){
                //setup the indexes
                pointerToPass[i].blockId = i;
                pointerToPass[i].threadId = j;
                //The third loop, copies over a collection of passwords for each THREAD 
                //within the current BLOCK
                for (int l = 0; l < numEach; l++) {
                    //Add the temporary passwords to the first block
                    if (runFlag == 1) {
                        for (int x = 0; x < temp.size(); x++){
                            //Convert
                            string tmp = temp.front();
                            char charTmp[1024];
                            strcpy(charTmp, tmp.c_str());
                            pointerToPass[i].passwords.push_back(charTmp);
                            temp.pop_front();
                        }
                        //Now never block run again
                        runFlag = 0;
                    }
                    //convert the passwords from string to char[] before adding
                    string tmp = passwords.front();
                    char charTmp[1024];
                    strcpy(charTmp, tmp.c_str());
                    pointerToPass[i].passwords.push_back(charTmp);
                    //now delete the item from passwords that has just been transfered
                    //over to the other list
                    passwords.pop_front();
                }
            }
        }
    }
    else {  
        //Start to transfer passwords
        //First calculate how many passwords each thread will be given to check
        int numEach = sizeOfList / totalNumThreads;
        //The first for loop, iterates through each BLOCK within the GRID
        for (int i = 0; i < (gridSize*gridSize); i++) {
            //The second loop, iterates through each THREAD within the current BLOCK
            for (int j = 0; j < (blockSize*blockSize); j++){
                //setup the indexes
                pointerToPass[i].blockId = i;
                pointerToPass[i].threadId = j;
                //The third loop, copies over a collection of passwords for each THREAD 
                //within the current BLOCK
                for (int l = 0; l < numEach; l++) {
                    //convert the passwords from string to char[] before adding
                    string tmp = passwords.front();
                    char charTmp[1024];
                    strcpy(charTmp, tmp.c_str());
                    pointerToPass[i].passwords.push_back(charTmp);
                    //now delete the item from passwords that has just been transfered
                    //over to the other list
                    passwords.pop_front();
                }
            }
        }
    }
}
//Now onto the parallel
__device__ bool comparison(indvPasswords *collection, char *password, int *totalThreads)
{
    //return value
    bool val = false;
    //first calculate the block ID
    int currentBlockId = blockIdx.y * gridDim.x + blockIdx.x;
    //calculate the thread ID
    int currentThreadId = currentBlockId * blockDim.y * blockDim.x + threadIdx.y * blockDim.x + threadIdx.x;
    //Now go and find the data required for this thread
    //Get the block
    for (int i = 0; i < (int)totalThreads; i++) {
        if (collection[i].blockId == currentBlockId) {
            //Now check the thread id
            if (collection[i].threadId == currentThreadId) {
                //Now begin comparison
                for (int j = 0; j < collection[i].passwords.size(); j++)
                {
                    if (password == collection[i].passwords.front()) {
                        //password found!
                        val = true;
                        break;
                    }
                    //delete the recently compared password
                    collection[i].passwords.pop_front();
                }
            }
        }
    }
    return val;
}
__global__ void kernelComp(indvPasswords *collection, char *password, int *totalThreads)
{
    comparison(collection, password, totalThreads);
}
int main()
{
    int size = totalNumThreads;
    //grid and block sizes
    dim3 gridDim(gridSize, gridSize, 1);
    dim3 blockDim(blockSize, blockSize, 1);
    //Get the password
    string tmp = passwordFile();
    //convert 
    char pwd[1024];
    strcpy(pwd, tmp.c_str());
    indexing();
    //device memory pointers
    indvPasswords* array_d;
    char *pwd_d;
    int *threadSize_d;
    int *threads = &totalNumThreads;
    //allocate host memory
    pwd_d = (char*)malloc(1024);


    //allocate memory
    cudaMalloc((void**)&array_d, size);
    cudaMalloc((void**)&pwd_d, 1024);
    cudaMalloc((void**)&threadSize_d, sizeof(int));
    //copy the data to the device
    cudaMemcpy(array_d, pointerToPass, size, cudaMemcpyHostToDevice);
    cudaMemcpy(pwd_d, pwd, 1024, cudaMemcpyHostToDevice);
    cudaMemcpy(threadSize_d, threads, sizeof(int), cudaMemcpyHostToDevice);
    //call the kernel
    kernelComp << <gridDim, blockDim>> >(array_d,pwd_d,threadSize_d);
    //copy results over
    return 0;
}