How to pass char matrix as parameter?

Question

I’m doing it wrong. Gosaria to know how could pass this array of names to work on the function?

void primeiro_ex(int *lista,char **nomes){}



void main(){
    int notas[60];
     char nomes[60][60];
    primeiro_ex(notas,nomes);

}

Answer 1

Some time ago I posted something like this, in ONLY and only translated the messages to post again here.

The program creates a block of parameters and calls a poor named function :( igual_main() with the same arguments.

So you can see how to create the block, how to dynamically increase and how to release at the end. It is the one used to load for example a text line by line to memory. The allocation is done in blocks to be more efficient.

Sadide of the example

Bloco estendido para um total de 8 ponteiros
Bloco estendido para um total de 12 ponteiros
Bloco estendido para um total de 16 ponteiros
Bloco estendido para um total de 20 ponteiros
        17 strings no bloco:
                1 de 17: 'nome do programa'
                2 de 17: 'Criando'
                3 de 17: 'um'
                4 de 17: 'bloco'
                5 de 17: 'de'
                6 de 17: 'strings'
                7 de 17: ','
                8 de 17: 'do'
                9 de 17: 'modo'
                10 de 17: 'como o '
                11 de 17: 'sistema'
                12 de 17: 'faz'
                13 de 17: 'para'
                14 de 17: 'main()'
                15 de 17: 'em todo '
                16 de 17: 'programa'
                17 de 17: 'C'
        20 ponteiros alocados
        17 argumentos lidos
        3 ponteiros a liberar
        Tamanho total ajustado para 17 ponteiros
        Chamando igual_main() com esses argumentos

        Em "main()": 17 argumentos

       0        'nome do programa'
       1        'Criando'
       2        'um'
       3        'bloco'
       4        'de'
       5        'strings'
       6        ','
       7        'do'
       8        'modo'
       9        'como o '
      10        'sistema'
      11        'faz'
      12        'para'
      13        'main()'
      14        'em todo '
      15        'programa'
      16        'C'


        "main()" retornou 0
        Agora libera o bloco todo e encerra


F i m

The program C

#define _BLOCO_ 4

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

typedef struct
{
    int     argc;
    char**  argv;
}   Vetor_de_strings;

int igual_main(int, char**);

int main(void)
{
    const int   n_parm = 16;
    const char* strings_de_teste[] =
    {
        "Criando", "um", "bloco", "de",
        "strings", ",", "do", "modo",
        "como o ", "sistema", "faz", "para" ,
        "main()",  "em todo ", "programa", "C"
    };

    /*
    memoria e alocada em blocos de _BLOCO_ ponteiros.
    Sempre que preciso um novo bloco eh. Ao final o bloco 
    eh ajustado para o tamanho exato e os ponteiros nao 
    usados sao liberados via free()

    Ex: para 12 strings e _BLOCO_ 5:  3 blocos serao alocados
    para um total de 15. Ao final da criacao os 3 ponteiros 
    nao usados sao liberados

    */
    Vetor_de_strings ex; // exemplo
    int N = _BLOCO_;
    ex.argc = 0;
    ex.argv = (char**)malloc(sizeof(char*) * _BLOCO_);
    const char* program_name = "nome do programa";
    ex.argv[ex.argc] = (char*)malloc(1 + strlen(program_name));
    strcpy(ex.argv[ex.argc], program_name);
    ex.argc += 1; // 1st arg. That was easy

    // carrega o vetor argv
    for (int i = 0; i < n_parm; i += 1)
    {   // cada um
        if (ex.argc >= N)
        {   // bloco cheio
            N = N + _BLOCO_;
            char* new_block = realloc(ex.argv, (N * sizeof(char*)));
            printf("Bloco estendido para um total de %d ponteiros\n", N);
            ex.argv = (char**)new_block;
        };
        ex.argv[ex.argc] = (char*)malloc(1 + strlen(strings_de_teste[i]));
        strcpy(ex.argv[ex.argc], strings_de_teste[i]);
        ex.argc += 1;
    };  // for()
    printf("\t%d strings no bloco:\n", ex.argc);
    for (int i = 0; i < ex.argc; i += 1)
    {
        printf("\t\t%d de %d: '%s'\n", 1 + i, ex.argc, ex.argv[i]);
    };

    printf("\t%d ponteiros alocados\n", N);
    printf("\t%d argumentos lidos\n", ex.argc);
    if (N == ex.argc)
        printf("\tNada a liberar\n");
    else
    {
        printf("\t%d ponteiros a liberar\n", N - ex.argc);
        char* new_size = realloc(ex.argv, (ex.argc * sizeof(char*)));
        printf("\tTamanho total ajustado para %d ponteiros\n", ex.argc);
        ex.argv = (char**)new_size;
    };
    printf("\tChamando igual_main() com esses argumentos\n");
    int res = igual_main(ex.argc, ex.argv);
    printf("\n\n\t\"main()\" retornou %d\n", res);
    printf("\tAgora libera o bloco todo e encerra\n");
    for (int i = 0; i < ex.argc; i += 1)
        free(ex.argv[i]);
    free(ex.argv);
    printf("\n\nF i m\n");
    return 0;
};

int igual_main(int argc, char** argv)
{
    printf("\n\tEm \"main()\": %d argumentos\n\n", argc);
    for (int i = 0; i < argc; i += 1)
        printf("%8d\t'%s'\n", i, argv[i]);
    return 0;
};  // nova_main()
//fim