Lunux задача

#include <cstdlib>
#include <iostream>
#include <stdio.h>
#include <conio.h>
#include <windows.h>
#include <Math.h>
#include <locale.h>
 
using namespace std;
HANDLE mutex,potok[100];
int count[26];
 
DWORD WINAPI Summa( LPVOID p ) 
{
char* stroka;
float s=0;
stroka= (char*)p;
int num = 0;
//printf("get str in thread =%s \n", stroka);
while (*stroka) {
char symb = *stroka++;
 
//printf (" %c", symb);
//printf (" %d", symb);
num = -1;
if ( symb >= 'a' && symb <='z' )
num = symb - 'a';
if ( symb >= 'A' && symb <='Z' )
num = symb - 'A';
if (num >= 0) {
 
count[num] ++;
//printf("symb %c num %d count[%d] %d\n", symb, num, num, count[num]);
}
}
 
ReleaseMutex(mutex); 
return 1;
}
 
int main(int argc, char *argv[])
{
SetConsoleCP(1251); 
SetConsoleOutputCP(1251); 
 
char buf[256];
int PART_OF_STR = 10; 
char buf1[5];
 
printf ("Inpdfut string: ");
gets(buf);
//printf("%s", buf);
 
 
for ( int i = 0; i < 26; i ++ )
count[i] = 0;
 
mutex=CreateMutex(NULL,TRUE,NULL); 
//puts("sozdanie"); 
 
int i = -1; 
while(WaitForSingleObject(mutex,1000)!= WAIT_TIMEOUT)
{ 
i++;
if (strlen(buf) >= i*5) {
strncpy(buf1, &buf[i*5], 5);
buf1[5] = '\0';
char* str = buf1;
potok[i]=CreateThread(NULL,1,Summa,(char*)str,0,NULL); 
SleepEx(1000,TRUE); 
} else
break;
 
}
puts("Result: \n");
WaitForSingleObject(mutex,INFINITE);
CloseHandle(mutex);
 
for(int j=0;j<=i;j++)
{
CloseHandle(potok[j]);
}
for ( int i = 0; i < 26; i ++ )
{
if (count[i] > 0)
printf("%c - %d\n", 'A'+i, count[i]);
}
 
puts("");
getch();
 
return 0;
}

#include <mutex>
#include <thread>
#include <vector>
#include <iostream>
#include <algorithm>
 
 
int count[26];
std::mutex mutex;
 
void sum(int thread_num, const char *begin, const char *end)
{
    {   
        std::unique_lock<std::mutex> lc(mutex);
        std::cout << "started thread: " << std::dec << thread_num
                  << " processing: " << std::string(begin, end - begin) << std::endl;
    }   
 
    for ( ; begin < end; ++begin)
    {   
        if (*begin >= 'A' && *begin <='Z')
        {
            int idx = *begin - 'A';
 
            std::unique_lock<std::mutex> lc(mutex);
            count[idx]++;
        }
    }   
}
 
int main(int argc, char *argv[])
{
    std::string line;
    std::getline(std::cin, line);
    std::transform(line.begin(), line.end(), line.begin(),
        [](unsigned char c){ return std::toupper(c); }); 
 
    std::vector<std::thread> threads;
    int hw_threads_count = std::thread::hardware_concurrency();
    int hw_threads_last = std::max(hw_threads_count - 1, 0); 
 
    int step = line.size() / hw_threads_count;
    
    for (int thread_num = 0; thread_num < hw_threads_last; ++thread_num)
    {   
        const char *begin = line.c_str() + thread_num * step;
        const char *end = begin + step;
        threads.push_back(std::thread(sum, thread_num, begin, end));
    }   
    threads.push_back(std::thread(sum, hw_threads_last, line.c_str() + hw_threads_last * step, line.c_str() + line.size()));
 
    for (auto &thread : threads)
    {   
        thread.join();
    }   
 
    for (int i = 0; i < 26; ++i)
    {   
        if (count[i] > 0)
        {
            std::cout << "char " << (char)('A' + i) << " counts " << count[i] << " times"
                      << std::endl;
        }
    }
 
    return 0;
}