使用std :: async

时间:2016-08-08 23:16:19

标签: c++ c++11

我一直在尝试使用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)

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

2 个答案:

答案 0 :(得分:0)

您的算法将源字符串分为两个子字符串,第一个是&#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

答案 1 :(得分:-1)

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

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

算法(功能)多线程是

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