Question

我一直在尝试使用std :: async（或std :: thread）来转换字符串，但是找不到成功的算法。

void reverse(char* x, char* y)
{
    while (x < y)
    {
        char temp = *x;
        *x = *y;
        *y = temp;
        x++;
        y--;
    }
}

int main(int argc, char** argv)
{
    int numthreads = 2;
    char input[] = "abcdef";
    size_t size = strlen(input);
    size_t substrsize = 0;

    substrsize = size / numthreads;

    char* end = &input[strlen(input) - 1];
    char* begin = &(input[size-substrsize]);

    for (int i = 0; i < numthreads; i++)
    {
        std::async(std::launch::async, reverse, begin, end);
        end = begin -1; 
        begin = begin-substrsize;
    }

    cout << input << endl;    
    return 0;
}

为简单起见，我假设输入可以划分为相同大小的子串（即，大小％numthreads假定为零）

然而，在上面，我得到的输出是：

cbafed

我理解这个输出，因为abc和def是相反的。但是，正确的输出将是 fedcba 。

是否可以扩展此代码以实现所需的输出？我试图将返回的未来存储在向量中（通过移动），然后调用get on it但它没有帮助（可能是因为函数返回void）

请提供一些提示或建议，以使其正常工作。非常感谢！

Answer 1

您的算法将源字符串分为两个子字符串，第一个是＆＃34; def＆＃34;。你的反向＆＃34;算法交换＆＃34; d＆＃34;和＆＃34; f＆＃34;，inc / decs指向指向＆＃34; e＆＃34;和互换＆＃34; e＆＃34;与自己。

结果是两个反向的子串：

abc  def

变为

cba  fed

您需要更改反向算法以获取3个输入：

void reverse(char* begin, const char* const end, char* back) {
    while (begin != end) {
        std::swap(*(begin++), *(--back));
    }
}

然后你需要用字符串的子范围来调用它：

size_t subtrlen = 2;
reverse(input + 0, input + substrlen, input + sizeof(input) - 1);
reverse(input + substrlen, input + 3, input + sizeof(input) - 1 - substrlen);

演示：

#include <iostream>
#include <string.h>

void reverse(char* begin, const char* const end, char* back) {
    while (begin != end) {
        std::swap(*(begin++), *(--back));
    }
}

int main(int argc, char** argv)
{
    char input[] = "abcdef";
    size_t len = strlen(input);
    size_t substrlen = 2;
    std::cout << input << std::endl;    
    reverse(input, input + substrlen, input + len);
    reverse(input + substrlen, input + substrlen, input + len - substrlen);
    std::cout << input << std::endl;
    return 0;
}

http://ideone.com/gGjB9D

Answer 2

如果我没错，你试图以多线程方式反转字符串。所以你需要一个在多线程上下文中执行的算法。

这是我可以为你提出的一个简单的解决方案。

算法（功能）多线程是

void reverse_str_mt(char* str,
                const size_t len,
                const size_t id_thread,
                const size_t max_num_threads) {
  // Some assertion on input parameters
  assert(str != nullptr);
  assert(max_num_threads != 0);

  // In case the num of threads is greater than the len of the string
  if (id_thread > len) {
    assert(max_num_threads > len);
    return;
  }

  // Swap operation
  for (size_t i = id_thread; i <= len / 2; i += max_num_threads) {
    std::swap(str[i], str[len - i - 1]);
  }
}

你可以像这样操作一个字符串：

int main(int argc, char *argv[]) {
  static constexpr size_t NUM_THREADS = 10;
  char str[] = "123456";
  const auto len = strlen(str);

  std::vector<std::thread> threads;
  for (size_t i = 0; i < NUM_THREADS; ++i) {
    threads.emplace_back(reverse_str_mt, str, len , i, NUM_THREADS);
  }

  // Join threads
  for (auto& t : threads) {
    t.join();
  }

  // Print the result
  std::cout << str << std::endl;

  return 0;
}

为了完整起见，您应该包含的标题是：

#include <iostream>
#include <algorithm>
#include <vector>
#include <string>
#include <thread>
#include <cstring>
#include <cassert>

这是一个可运行的example。

使用std :: async

2 个答案: