1. char chars[]={'GT','CSS','etc', ..... ,'voila','fin'}; // en vrais on s'en fou du contenu ...
2. cout << "Nombre de tread: " << endl;
3. cin >> tread;
4. int decoupage;
5. decoupage = 59/tread;

1. std::vector<std::string> mesChaines { "GT", "CSS", "etc", "voila", "fin" };

#include <iostream>
#include <cstdlib>
#include <cstring>
#include <cmath>
 
using namespace std;
 
int main ()
{
    char chars[59]={'S','F','J','B','V','K','E','S','H','L','R','V','Z','B','H','H', \
    'H','F','P','P','A','T','F','F','E','B','I','G','Z','Y','V','U','E','B','R''H', \
    'Q','A','Z','F','Y','C','C','I','U','Y','V','L','H','K','K','B','G','H','P','I','H','A','T'};
    int nb;
    int lg_morceaux;
    int cpt;
    int i;
    
    cout<<"nb de morceaux?";
    cin>>nb;
    
    if(nb<2 || nb>25) //25 pris au pif...
    {
        cout<<"error";
        return 0;
    }
    
    lg_morceaux=ceil(59.0/nb);
    cout<<"lg_morceaux: "<<lg_morceaux<<endl;
    
    for(cpt=0; cpt<=59; cpt+=lg_morceaux)
    {
        int lg=cpt+lg_morceaux>59?(59-cpt):(lg_morceaux);
        
        cout<<"segment start: "<<cpt<<" long: "<<lg;
        
        //memory-leak, faudra évidemment garder un pointeur sur chaque ensemble de chars, c'est juste pour la démo de l'algo
        //(pas envie d'écrire trop...)
        char *ptr=(char*)malloc(lg*sizeof(char));
        if(ptr==NULL)
        {
            cout<<"error";
            return 0;
        }
        
        memcpy(ptr, chars+cpt, lg);
        
        cout<<" contenu: ";
        for(i=0; i<lg; i++)
        {
            cout<<ptr[i]<<" ";
        }
        cout<<endl;
        
    }
    
    return 0;
}

1. #include <iostream>
2. #include <vector>
3. #include <string>
5. std::vector<std::string> split(const std::string &str, int parts) {
6.   std::vector<std::string> svec;
7.   svec.reserve(parts);
9.   int partsize = str.length()/((str.length()%parts)?(parts - 1):parts);
11.   std::size_t pos = 0;
12.   while (parts--) {
13.       svec.push_back(str.substr(pos, partsize));
14.       pos += partsize;    
15.   }
16.   return svec;
17. }
19. int main(int argc, char **argv) {
21.     const std::string sample =
22.         "Lorem ipsum dolor sit amet, "
23.         "consectetur adipiscing elit, "
24.         "sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. "
25.         "Ut enim ad minim veniam, "
26.         "quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. "
27.         "Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. "
28.         "Excepteur sint occaecat cupidatat non proident, "
29.         "sunt in culpa qui officia deserunt mollit anim id est laborum.";
31.     int chunknums = 14;
32.     std::vector<std::string> chunks = split(sample, chunknums);
33.     for (int i = 0; i < chunknums; ++i)
34.         std::cout << chunks[i] << std::endl;
36.     return 0;
37. }

1. #include <stdio.h>
2. #include <stdlib.h>
3. #include <string.h>
5. char **split(char *str, int parts) {
6.     char **buffers = NULL;
8.     int len = strlen(str);
9.     int partsize = len/((len%parts)?(parts - 1):parts);
10.     int lastsize = len - (partsize * (parts - 1));
12.     char **b, *p;
13.     int size;
14.     b = buffers = malloc(parts * sizeof(char*));
15.     while (parts--) {
16.         size = parts?partsize:lastsize;
17.         p = *b = malloc(size + 1);
18.         while (size--) {
19.             *p++ = *str++;
20.         }
21.         *p = 0;
22.         b++;
23.     }
24.     return buffers;
25. }
27. int main(int argc, char **argv) {
28.     int i;
29.     char sample[] =
30.         "Lorem ipsum dolor sit amet, "
31.         "consectetur adipiscing elit, "
32.         "sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. "
33.         "Ut enim ad minim veniam, "
34.         "quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. "
35.         "Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. "
36.         "Excepteur sint occaecat cupidatat non proident, "
37.         "sunt in culpa qui officia deserunt mollit anim id est laborum.";
39.     int chunknums = 14;
40.     char **chunks = split(sample, chunknums);
41.     for (i = 0; i < chunknums; ++i) {
42.         printf("%s\n", chunks[i]);
43.     }
45.     for (i = 0; i < chunknums; ++i) {
46.         free(chunks[i]);
47.     }
48.     free(chunks);
49.     return 0;
50. }

1. #include <stdio.h>
2. #include <stdlib.h>
3. #include <string.h>
5. /* découpe la chaine str en parts morceaux, les parts-1 premières étant de taille égale maximale
6. * et renvoie un pointeur sur les morceaux */
7. char **split(char *str, int parts) {
8.     int len = strlen(str);
9.     int partsize = len/((len%parts)?(parts - 1):parts);
10.     int lastsize = len - (partsize * (parts - 1));
12.     char **buffers = malloc(parts * sizeof(char*));
13.     for (int i = 0; i < parts; ++i) {
14.         int size = (parts - i - 1)?partsize:lastsize;
15.         buffers[i] = malloc(size + 1);
16.         memcpy(buffers[i], str, size);
17.         buffers[i][size] = 0;
18.         str += size;
19.     }
20.     return buffers;
21. }
23. int main(int argc, char **argv) {
24.     char sample[] =
25.         "Lorem ipsum dolor sit amet, "
26.         "consectetur adipiscing elit, "
27.         "sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. "
28.         "Ut enim ad minim veniam, "
29.         "quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. "
30.         "Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. "
31.         "Excepteur sint occaecat cupidatat non proident, "
32.         "sunt in culpa qui officia deserunt mollit anim id est laborum.";
34.     int chunknums = 14;
35.     char **chunks = split(sample, chunknums);
36.     for (int i = 0; i < chunknums; ++i) {
37.         puts(chunks[i]);
38.     }
40.     for (int i = 0; i < chunknums; ++i) {
41.         free(chunks[i]);
42.     }
43.     free(chunks);
44.     return 0;
45. }

1. #include <stdio.h>
2. #include <stdlib.h>
3. #include <string.h>
5. /* découpe la chaine str en parts morceaux, les parts-1 premières étant de taille égale maximale
6. * et renvoie un pointeur sur les morceaux */
7. char **split(char *str, int parts) {
8.     int len = strlen(str);
9.     int partsize = len/((len%parts)?(parts - 1):parts);
10.     int lastsize = len - (partsize * (parts - 1));
12.     char **buffers = malloc(parts * sizeof(char*));
13.     for (int i = 0; i < parts; ++i) {
14.         int size = (parts - i - 1)?partsize:lastsize;
15.         buffers[i] = malloc(size);
16.         memcpy(buffers[i], str, size);
17.         str += size;
18.     }
19.     return buffers;
20. }
22. int main(int argc, char **argv) {
23.     char sample[] =
24.         "Lorem ipsum dolor sit amet, "
25.         "consectetur adipiscing elit, "
26.         "sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. "
27.         "Ut enim ad minim veniam, "
28.         "quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. "
29.         "Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. "
30.         "Excepteur sint occaecat cupidatat non proident, "
31.         "sunt in culpa qui officia deserunt mollit anim id est laborum.";
33.     int chunknums = 14;
34.     char **chunks = split(sample, chunknums);
36.     int len = strlen(sample);
37.     int partsize = len/((len%chunknums)?(chunknums - 1):chunknums);
38.     int lastsize = len - (partsize * (chunknums - 1));
39.     for (int i = 0; i < chunknums; ++i) {
40.         int size = (chunknums - i - 1)?partsize:lastsize;
41.         fwrite(chunks[i], size, 1, stdout);
42.         fwrite("\n", 1, 1, stdout);
43.     }
45.     for (int i = 0; i < chunknums; ++i) {
46.         free(chunks[i]);
47.     }
48.     free(chunks);
49.     return 0;
50. }