求助：将wchar_t数组改为全局并在运行时动态构建的语法实现

The root issue is a pointer type mismatch: your original daFactors is an array of wchar_t* pointers, but your global declaration uses wchar_t* instead of wchar_t**. Fixing this type mismatch is the first step to resolving the conversion error.

Corrected Global Declarations #

Replace your existing global declaration with:

#include <iostream>
#include <fstream>
#include <cstring>

// Corrected globals: daFactors is a pointer to an array of wchar_t pointers
wchar_t ** daFactors = nullptr;
long long ndaFactors = 0;

Implementation to Load from Text File #

This function reads lines from a text file, converts each line into the prefixed wchar_t array format you need, and populates the global dynamic array:

bool LoadFactorsFromFile(const wchar_t* filePath) {
    // Clean up existing data to avoid leaks
    if (daFactors != nullptr) {
        for (long long i = 0; i < ndaFactors; ++i) {
            delete[] daFactors[i];
        }
        delete[] daFactors;
        daFactors = nullptr;
        ndaFactors = 0;
    }

    std::wifstream inputFile(filePath);
    if (!inputFile.is_open()) {
        return false;
    }

    // First pass: count total lines to allocate correct array size
    std::wstring line;
    long long lineCount = 0;
    while (std::getline(inputFile, line)) {
        lineCount++;
    }
    inputFile.clear();
    inputFile.seekg(0);

    // Allocate array of pointers (matches wchar_t** type)
    daFactors = new wchar_t*[lineCount];
    ndaFactors = lineCount;

    long long currentIndex = 0;
    while (std::getline(inputFile, line)) {
        size_t stringLength = line.length();
        // Each entry needs stringLength + 1 elements: length prefix + characters
        wchar_t* entry = new wchar_t[stringLength + 1];
        entry[0] = static_cast<wchar_t>(stringLength); // Store length as first element
        // Copy string characters starting at index 1
        std::memcpy(entry + 1, line.c_str(), stringLength * sizeof(wchar_t));
        
        daFactors[currentIndex++] = entry;
    }

    inputFile.close();
    return true;
}

Key Details #

• Type Alignment: daFactors is now wchar_t**, which matches the return type of new wchar_t*[lineCount] (an array of pointers to wchar_t arrays).
• Memory Management: Each line from the file gets its own dynamically allocated wchar_t array, with the first element storing the string length (matching your original p1/p2 structure).
• Cleanup: The function first clears any existing data to prevent memory leaks, and you should repeat this cleanup logic when shutting down the program.
• Multi-threading Note: Since this data is used in a multi-threaded service, ensure loading completes before threads start accessing daFactors. If you need to reload data at runtime, use a mutex to protect access to the global variables during updates.

Example Usage #

int main() {
    if (LoadFactorsFromFile(L"factors.txt")) {
        // Verify loaded data matches original test structure
        for (long long i = 0; i < ndaFactors; ++i) {
            wchar_t* entry = daFactors[i];
            size_t len = entry[0];
            std::wcout << L"Entry " << i << L": Length=" << len << L", String=";
            for (size_t j = 1; j <= len; ++j) {
                std::wcout << entry[j];
            }
            std::wcout << std::endl;
        }
    } else {
        std::wcerr << L"Failed to open factors file" << std::endl;
    }

    // Cleanup on exit
    if (daFactors != nullptr) {
        for (long long i = 0; i < ndaFactors; ++i) {
            delete[] daFactors[i];
        }
        delete[] daFactors;
    }

    return 0;
}

内容的提问来源于stack exchange，提问作者szlamany