C++ OpenCL字符限制

printsomestuff

的两种实现最多只能写入res[7]（即：

WORLD！\0

或

！ELLOWO\0

）

main.cpp：

...
char A[16] = "HELLO ";
        cl::Buffer aBuf(context, CL_MEM_READ_WRITE, sizeof(A));

        char B[16] = "WORLD!";
        cl::Buffer bBuf(context, CL_MEM_READ_WRITE, sizeof(B));

        queue.enqueueWriteBuffer(aBuf, CL_TRUE, 0, sizeof(A) * sizeof(char), A);
        queue.enqueueWriteBuffer(bBuf, CL_TRUE, 0, sizeof(B) * sizeof(char), B);

        char res[16];
        cl::Buffer resBuf(context, CL_MEM_READ_WRITE, sizeof(res) * sizeof(char));

        cl::Kernel kernel(program, "printsomestuff");
        kernel.setArg(0, aBuf);
        kernel.setArg(1, bBuf);
        kernel.setArg(2, resBuf);

        queue.enqueueTask(kernel);
        //queue.enqueueNDRangeKernel(kernel, cl::NullRange, cl::NDRange(32), cl::NullRange);

        queue.enqueueReadBuffer(resBuf, CL_TRUE, 0, sizeof(resBuf), res);

        std::cout << res;
...

。。。
字符A[16]=“你好”；
cl：：缓冲区aBuf（上下文，cl_MEM_READ_WRITE，sizeof（A））；
char B[16]=“世界！”；
cl：：缓冲区bBuf（上下文，cl_MEM_READ_WRITE，sizeof（B））；
queue.enqueueWriteBuffer（aBuf，CL_TRUE，0，sizeof（A）*sizeof（char），A）；
queue.enqueueWriteBuffer（bBuf，CL_TRUE，0，sizeof（B）*sizeof（char），B）；
charres[16]；
cl：：缓冲区resBuf（上下文，cl_MEM_READ_WRITE，sizeof（res）*sizeof（char））；
cl：：内核（程序，“printsomestuff”）；
setArg（0，aBuf）；
setArg（1，bBuf）；
setArg（2，resBuf）；
排队任务（内核）；
//enqueueNDRangeKernel（kernel，cl:：NullRange，cl:：NDRange（32），cl:：NullRange）；
enqueueReadBuffer（resBuf，CL_TRUE，0，sizeof（resBuf），res）；
std:：cout
sizeof（A）
当
A
是
char*
是指针的大小，而不是数组的长度时。因此，如果将
字符A[16]
传递给此函数：

kernel void printsomestuff(__global char *A, __global char *B,
                           __global char *res) {

sizeof（A）
是指针的大小，通常为4或8
char
s。它不知道长度


您需要将大小作为单独的参数提供，或者使用为承载此类型的数据而创建的类型，如
std:：string

如果只有固定大小的
char
数组，则可以对函数进行一些调整，使其保留数组范围，如下所示：

template<std::size_t Asize, std::size_t Bsize, std::size_t Ressize>
kernel void printsomestuff(__global char (&A)[Asize], __global char (&B)[Bsize],
                           __global char (&res)[Ressize]) {

模板
内核void printsomestuff（uuu全局字符（&A）[Asize]，uuu全局字符（&B）[Bsize]，
__全局字符（&res）[Ressize]）{

（我真的不知道
\uu global
做什么，但我会把它留在里面）

您现在有了在函数中需要使用的所有尺寸。

谢谢你，Ted，实际上是res太小了：“queue.enqueueReadBuffer（resBuf，CL_TRUE，0，16，res）；” works@lemmer很好，但是太长了，读不下去了。如果你以后改变任何东西，很难记住所有的地方。关于<代码>·鲁斯兰GooG/<代码>，请看“@ @ WHOA”，这是很多值得阅读的地方。）
template<std::size_t Asize, std::size_t Bsize, std::size_t Ressize>
kernel void printsomestuff(__global char (&A)[Asize], __global char (&B)[Bsize],
                           __global char (&res)[Ressize]) {