Ir ao conteúdo
  • Cadastre-se

C++ Função Rotina em C++


Posts recomendados

Como faço a rotina para poder responder esse exercicio?

Preciso fazer em C++

 

Elabore uma função que receba como parâmetro uma matriz A (com 6 linhas e 6 colunas) e multiplique cada linha pelo elemento da diagonal principal da linha. A função deverá retornar a matriz alterada para ser mostrada no programa principal.

Link para o post
Compartilhar em outros sites

@Moraes_27    imaginando que você sabe como enviar uma matriz para uma função como parâmetro ,  o retorno de uma matriz é o que complica , pois o compilador não consegue fazer isso do mesmo modo que uma variável simples ,  então precisa retornar como ponteiro :

int func(int mat[6][6])
{
    // faz as modificações na matriz e retorna ela inteira
    return **mat;  // retorna um ponteiro para ponteiro
}
// na main escreve o que está na matriz retornada

poste o código que você tiver feito e ajudaremos caso precise   .

Link para o post
Compartilhar em outros sites
23 horas atrás, Moraes_27 disse:

Como faço a rotina para poder responder esse exercicio?

Preciso fazer em C++

 

Elabore uma função que receba como parâmetro uma matriz A (com 6 linhas e 6 colunas) e multiplique cada linha pelo elemento da diagonal principal da linha. A função deverá retornar a matriz alterada para ser mostrada no programa principal.

Se você não conhece, ou não gosta, de trabalhar com ponteiros, uma solução seria:

 

void func(int mat[][6])
{
  // faz a multiplicacao conforme o problema.
}

 

Deste modo a função altera a matriz original, ou seja, ela não cria uma cópia da mesma, pois estamos passando-a por referência.

 

AVISO: vetores (arrays) na linguagem C e C++ são ponteiros constantes. Matrizes, especificamente, são um vetor de ponteiros (array of pointers). Acredito que essa informação não mude de compilador para compilador. Por este motivo, no retorno da função, a matriz original é alterada.

Experimente fazer o seguinte:

#include <stdio.h>

void f(int a)
{
	a = 10;
}

void h(int a[1])
{
	a[0] = 10;
}

void main()
{
	int a = 1, b[1] = { 1 };
	f(a);
	h(b);
	printf("a: %d\n", a);
	printf("b: %d\n", b[0]);
}

 

Pergunta: Por que a variável "a" não alterou o seu valor e a variável "b" alterou?
Resposta: A variável "b" é um ponteiro!

 

 

Caso queira criar um cópia para não alterar a matriz original, você deve, obrigatoriamente, mexer com ponteiros duplos. Daí, a declaração de função muda para:

int **func(int mat[][6])
{
  int **my_pointer = NULL;
	/*
    	Aqui você deve declarar um ponteiro pra pointeiro (int **) e 
        fazer a alocação dinâmica de memória
    */
  return my_pointer;
}

Deste modo, você preserva a sua matriz o original, neste caso a mat[][6], e retorna o resultado em uma matriz.

 

Acredito que a solução dada por @devair1010 seria multiplicar o elemento da diagonal principal pela linha correspondente, porém, a forma que ele escreveu não faz isso. Da maneira como foi dada a solução, a função dele retorna sempre o primeiro elemento de "mat".

 

Assim, outra maneira de resolver isso seria:

void func(int mat[2], const int linha)
{
	/*
		Aqui você escreverá um loop que fará a iteração na linha.
        O parâmetro "linha", seria a posição do elemento da diagonal principal da linha em questão
	*/
	return 0;
}

int main(int argc, char *argv[])
{
  	for(int i = 0; i < LINHAS; i++)
    {
      func(mat[i], i);
    }
  	return 0;
}

Desse modo, você altera a matriz original também.

Qualquer dúvida é só escrever que te ajudo.

Link para o post
Compartilhar em outros sites
59 minutos atrás, Kyul disse:

AVISO: vetores (arrays) na linguagem C e C++ são ponteiros constantes. Matrizes, especificamente, são um vetor de ponteiros (array of pointers). Acredito que essa informação não mude de compilador para compilador. Por este motivo, no retorno da função, a matriz original é alterada.

Experimente fazer o seguinte:

Seu exemplo está errado!

Direto do livro C completo e total pagina 92.

Citação

Uma matriz(unidimensional) é uma coleção de variáveis do mesmo tipo que é referenciada por um nome comum.
Um elemento especifico em uma matriz é acessado por meio de um índice. em C, todas as matrizes consistem em
posições contíguas na memória. o endereço mais baixo corresponde ao primeiro elemento e o mais alto,
ao último elemento. Matrizes podem ter de uma a várias dimensões. A matriz mais comum em C é a string,
que é simplesmente uma matriz de caracteres terminadas por um nulo. Essa abordagem a strings dá a C maior
poder e eficiência que às outras linguagens.

Recomendo ler a sessão sobre ponteiros também.

 

Um exemplo "correto".

Spoiler

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

int (*devolve(void))[4]
{
    int (*matriz)[4] = malloc(sizeof(int[4][4]));
    int linhas, colunas, contador = 0;
    for (linhas = 0; linhas < 4; linhas++) {
        for (colunas = 0; colunas < 4; colunas++) {
            matriz[linhas][colunas] = contador;
            contador++;
        }
    }
    return(matriz);
}

int main(void)
{
    int (*ponteiro)[4], linhas, colunas;
    /* Pega a matriz alocada dinamicamente */
    ponteiro = devolve();
    /* Mostra a matriz */
    for (linhas = 0; linhas < 4; linhas++) {
        for (colunas = 0; colunas < 4; colunas++) {
            printf("%i|", ponteiro[linhas][colunas]);
        }
        putchar('\n');
    }
    /* Espera a tecla enter */
    getchar();
    /* Apaga a matriz */
    free(ponteiro);
    return(0);
}

 

Creio eu que esse meu exemplo deva sanar qualquer duvida sobre ponteiros e matrizes.

  • Haha 1
Link para o post
Compartilhar em outros sites
2 horas atrás, Kyul disse:

AVISO: vetores (arrays) na linguagem C e C++ são ponteiros constantes. Matrizes, especificamente, são um vetor de ponteiros (array of pointers). Acredito que essa informação não mude de compilador para compilador. Por este motivo, no retorno da função, a matriz original é alterada

 

isso não casa bem com isso

 

1 hora atrás, kgin disse:

Uma matriz(unidimensional) é uma coleção de variáveis do mesmo tipo que é referenciada por um nome comum.
Um elemento especifico em uma matriz é acessado por meio de um índice. em C, todas as matrizes consistem em
posições contíguas na memória. o endereço mais baixo corresponde ao primeiro elemento e o mais alto,
ao último elemento. Matrizes podem ter de uma a várias dimensões. A matriz mais comum em C é a string,
que é simplesmente uma matriz de caracteres terminadas por um nulo. Essa abordagem a strings dá a C maior
poder e eficiência que às outras linguagens

 

e nem o autor do livro nem o autor do post estão assim corretos. 

 

Não há matrizes em C. Apenas vetores e vetores de vetores e vetores de vetores de vetores e assim por diante.

 

@Kyul tem razão, uma "matriz multidimensional" PODE ser representada por um vetor de ponteiros. Mas no sentido matemático de uma matriz de 3 linhas por 4 colunas por 5 planos de um int ou char ou algum tipo primitivo em geral não é assim que se cria.

 

A tal matriz é apenas UM ponteiro e as contas dos índices são feitas por simples aritmética. E C reforça essa aritmética no caso dos ponteiros somando os valores de modo a ter o índice correto a partir de simples multiplicação e soma.

 

Se você cria isso usando um vetor de ponteiros essa lógica já era e nenhum algoritmo matemático via funcionar.

 

Numa matrix X de 3x4x5 de int se espera que o último dos 60 elementos esteja em *(X+59). E se construir essa matriz usando um vetor de ponteiros essa lógica já era.
 

image.png.490c74f91425c3f0734e7d39d5690e01.png

 

Essa é a definição em um clássico do planeta, livro texto de boa parte desses cursos em toda escola e cuja versão em português ao menos nessa edição é um desastre (eu conheci através de um usuário deste forum).

 

 

 

 

Em resumo: escreva um programa de teste e tente entender a diferença. Ao criar isso use sempre UM ponteiro e os deslocamentos, e C faz o resto. Ou crie os tais vetores de ponteiros e reescreva tudo.

 

 

 

 

 

 

  • Curtir 2
Link para o post
Compartilhar em outros sites

@kgin Olá. O livro descreve apenas superficialmente o que são vetores (arrays) e matrizes e está correto. Mas você já se perguntou o porquê de podermos acessar o elemento de um vetor alocado dinamicamente do mesmo modo que um vetor "estático"?

Por exemplo, o trecho de código a seguir ilustra o que eu quis dizer:

int *p = malloc(sizeof(int) * 4);
int q[4];

for(int i = 0; i < 4; i++)
  p[i] = (i + 1);
   
/* 
	Aqui nos somamos 4 bytes a cada iteração, uma vez que
    eh um pointeiro para inteiro e, na arquitetura x86_64
    um inteiro, geralmente, tem tamanho de 4 bytes;
    Aqui, nos poderiamos usar p[i], também;
*/
for(int i = 0; i < 4; i++)
{
  printf("%d ", *(p + i));
}
printf("\n");

/*
	Do mesmo modo, podemos tratar o tipo array.
    Neste caso fazemos o incremento da mesma maneira.  
    Aqui também poderiamos usar q[i].
*/
for(int i = 0; i < 4; i++)
{
  printf("%d ", *(q + i));
}
printf("\n");

free(p);

 

Logo, neste caso, nós podemos enxergar os arrays como ponteiros e vice-versa.

Porém, não é possível mudar o endereço no qual um array aponta.

Se você tentar fazer isso:

*(p++) = 1;
*(q++) = 1;

printf("p: %d, %d\n", p[0], p[1]);
printf("q: %d, %d\n", q[0], q[1]);

Você não vai nem mesmo compilar, pois o array é um tipo (o compilador vai te dizer isso), e o que você pode tirar disso é que ele é constante, ou seja, você nunca pode mudar o endereço no qual ele aponta, que é o endereço do primeiro elemento do array.

Mas você deve estar se perguntando, por que pensar dessa maneira? A resposta é porque é importante saber como as coisas são implementadas de fato. Isso pode te ajudar a resolver alguns problemas, inclusive de segurança.

19 minutos atrás, arfneto disse:

isso não casa bem com isso

Fui infeliz na escolha das palavras, é verdade, mas o que eu queria enfatizar aqui é que se você for atribuir uma matriz à um ponteiro de ponteiro, o compilador (ao menos o GCC) fala que você está tentando uma atribuição entre tipos incompatíveis int (*)[] à um int **. De fato, não me expressei bem.

19 minutos atrás, arfneto disse:

Não há matrizes em C. Apenas vetores e vetores de vetores e vetores de vetores de vetores e assim por diante.

Bem, matriz é uma abstração, assim como int, char, double, pois no fundo, no fundo, são bytes e você pode dar qualquer significado à eles.

Ponteiros são variáveis utilizadas para manipulação de endereços de memória. Você dá a utilidade necessária para eles.

E, sim, o que você falou eu concordo, um N-D array pode ser alocado com um único ponteiro se assim preferir, no fundo, o compilador, ou você, faz os cálculos de endereços de memória para acessar tais elementos.

 

O único livro que peguei pra pegar algumas coisas de C foi o livro dos próprios criadores da linguagem (Denis Ritchie e Brian Kernigham), então não tenho referência de um livro pra essa linguagem. A maioria das coisas que aprendi foi com a referência do compilador GNU para a linguagem e Assembly.

  • Curtir 1
Link para o post
Compartilhar em outros sites
16 minutos atrás, Kyul disse:

Bem, matriz é uma abstração, assim como int, char, double, pois no fundo, no fundo, são bytes e você pode dar qualquer significado à eles.

Ponteiros são variáveis utilizadas para manipulação de endereços de memória. Você dá a utilidade necessária para eles.

E, sim, o que você falou eu concordo, um N-D array pode ser alocado com um único ponteiro se assim preferir, no fundo, o compilador, ou você, faz os cálculos de endereços de memória para acessar tais elementos

 

Não estava dando minha opinião. A fórmula é aquela do livro, para qualquer número de "dimensões".

 

Você pode usar um vetor de ponteiros como disse e implementar assim. E outro vetor para outra "dimensão", como eu também disse,  mas aí vai perder todo o suporte do compilador (qualquer um) em termos de aritmética de ponteiros se passar de uma dimensão.

 

FORTRAN tem matrizes, com até 7 dimensões se bem lembro. C e sucessoras não.
 

20 minutos atrás, Kyul disse:

Fui infeliz na escolha das palavras, é verdade, mas o que eu queria enfatizar aqui é que se você for atribuir uma matriz à um ponteiro de ponteiro, o compilador (ao menos o GCC) fala que você está tentando uma atribuição entre tipos incompatíveis int (*)[] à um int **. De fato, não me expressei bem

 

Você pode montar a matriz assim, como vetor de ponteiros, mas não é esperto, pela razão que mostrei: aquela formula do livro: qualquer elemento da tal "matriz" usando base + deslocamento.

 

Um int[][][] como o compilador vai te dizer --- qualquer um --- pode ser visto como int*** mas não o contrário. pointer decay não é de mão dupla. 

 

Programe aquela matriz 3x4x5 de exemplo como falei como int* ou como um vetor de ponteiros e terá a diferença clara.

 

:) 

  • Curtir 1
Link para o post
Compartilhar em outros sites
10 minutos atrás, arfneto disse:

Um int[][][] como o compilador vai te dizer --- qualquer um --- pode ser visto como int*** mas não o contrário. pointer decay não é de mão dupla.

Sim, foi o que expliquei na resposta acima:

35 minutos atrás, Kyul disse:

Logo, neste caso, nós podemos enxergar os arrays como ponteiros e vice-versa.

Porém, não é possível mudar o endereço no qual um array aponta.

Se você tentar fazer isso:



*(p++) = 1;
*(q++) = 1;

printf("p: %d, %d\n", p[0], p[1]);
printf("q: %d, %d\n", q[0], q[1]);

Você não vai nem mesmo compilar, pois o array é um tipo (o compilador vai te dizer isso), e o que você pode tirar disso é que ele é constante, ou seja, você nunca pode mudar o endereço no qual ele aponta, que é o endereço do primeiro elemento do array.

Aqui, não dá pra fazer algumas coisas que você faz com um ponteiro em um array. Esse exemplo é um deles. Note que "algumas" aqui significa quase todas as coisas que você faz com ponteiro, por isso, sim, concordo com você, não é uma mão dupla em alguns casos.

 

 

10 minutos atrás, arfneto disse:

Não estava dando minha opinião. A fórmula é aquela do livro, para qualquer número de "dimensões".

kkkk Eu sei que você não tava dando sua opinião, mas o que eu quis dizer aqui, talvez não tenha ficado bem colocado, é que você me falou sobre a aritmética de endereços envolvendo ponteiros, que é o que o compilador faz por debaixo dos panos.

  • Curtir 1
Link para o post
Compartilhar em outros sites
Em 05/05/2021 às 22:27, Kyul disse:

O livro descreve apenas superficialmente o que são vetores (arrays) e matrizes e está correto. Mas você já se perguntou o porquê de podermos acessar o elemento de um vetor alocado dinamicamente do mesmo modo que um vetor "estático"?

 

Não, não está correto e acho que eu mostrei porque. 

 

O exemplo com um vetor int[] não vai de fato levar a nada. A diferença ocorre a partir da segunda dimensão se usar o tal conceito de array de ponteiros.

 

ao construir algo como int[][][] como um array de ponteiros se inviabiliza o cálculo como o compilador executa. Fica tudo por conta do programador.

 

C e C++ e C++ usa, como todas linguagens, o conceito de base e deslocamento. Só isso. E a fórmula é a que citei no outro post.

 

Em 05/05/2021 às 22:27, Kyul disse:

O único livro que peguei pra pegar algumas coisas de C foi o livro dos próprios criadores da linguagem (Denis Ritchie e Brian Kernigham), então não tenho referência de um livro pra essa linguagem. A maioria das coisas que aprendi foi com a referência do compilador GNU para a linguagem e Assembly

 

O livro que eu citei não é um livro sobre C. Trata-se de um livro famoso sobre estruturas de dados implementadas em C e é um livro-texto desses cursos em escolas do mundo todo desde sua 1a edição em '95.

 

Exemplo, em C
 

Vou deixar um exemplo completo que talvez ajude a entender esses mecanismos.

 

Uma matriz int[4][3][2]

 

O programa gira em torno de uma matriz assim, 4xx3x2 com esses 24 int. E a aritmética de ponteiros, como usada pelo compilador, permite acessar essa matriz como

  • int[4][3]2]
  • int[4][6]
  • int[8][3]
  • int[24]

Alternando o acesso via índices e ponteiros e usando a fórmula clássica. Assim se pode ver o que acontece com os endereços e o modo como o compilador trabalha. Funcionaria em várias outras linguagens.

 

Eis a saida

 

Ultimo elemento com 3 Dim: matriz[3][2][1] =  2
Ultimo elemento com 3 Dim, mas usando ponteiro e indices: matriz[3][2][1] =  2
Ultimo elemento usando a formula generica: matriz[3][2][1] =  2
Ultimo elemento considerando matriz 4x6: matriz[3][5] =  2
Ultimo elemento considerando matriz 8x3: matriz[7][2] =  2
Ultimo elemento considerando vetor de 24: matriz[23] =  2


        Mudando as dimensoes da mesma matriz:


Uma unica dimensao, 24 elementos
Vetor[24]:
[ 99,  74,   4,  15,  26,   1,  72,  25,  67,  74,  64,  96,  73,\
89,  69,  56,  78,  27,  86,  76,  93,  84,  33,   2 ]


Duas dimensoes, 4x6
Vetor[4][6]:
[
        [ 99, 74,  4, 15, 26,  1 ]
        [ 72, 25, 67, 74, 64, 96 ]
        [ 73, 89, 69, 56, 78, 27 ]
        [ 86, 76, 93, 84, 33,  2 ]
]

Duas dimensoes, 8x3
Vetor[8][3]:
[
        [ 99, 74,  4 ]
        [ 15, 26,  1 ]
        [ 72, 25, 67 ]
        [ 74, 64, 96 ]
        [ 73, 89, 69 ]
        [ 56, 78, 27 ]
        [ 86, 76, 93 ]
        [ 84, 33,  2 ]
]

Tres dimensoes, 4x3x2
Vetor[4][3][2]:
[
        [
                [ 99, 74 ]
                [  4, 15 ]
                [ 26,  1 ]
]
        [
                [ 72, 25 ]
                [ 67, 74 ]
                [ 64, 96 ]
]
        [
                [ 73, 89 ]
                [ 69, 56 ]
                [ 78, 27 ]
]
        [
                [ 86, 76 ]
                [ 93, 84 ]
                [ 33,  2 ]
]
]

 

 

 

Eis o programa

 

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

int 	    mostra_vetor_1(int, int*, const char*);
int 	    mostra_vetor_2(int, int, int*, const char*);
int 	    mostra_vetor_3(int, int, int, int*, const char*);

int main()
{
    srand(210505);
    int     matriz[4][3][2];

    int(*p4x3x2)[4][3][2] = (int(*)[4][3][2]) matriz;
    int(*p4x6)[4][6] = (int(*)[4][6]) matriz;
    int(*p8x3)[8][3] = (int(*)[8][3]) matriz;
    int(*p24)[24] = (int(*)[24]) matriz;

    int* pInt = (int*)&matriz;
    for (int i = 0; i < 24; i += 1) pInt[i] = rand() % 100; // entre 0 e 99

    printf("Ultimo elemento com 3 Dim: matriz[%d][%d][%d] = %2d\n", 3, 2, 1,
        matriz[3][2][1]);
    printf("Ultimo elemento com 3 Dim, mas usando ponteiro"
        " e indices: matriz[%d][%d][%d] = %2d\n", 3, 2, 1, (*p4x3x2)[3][2][1]);
    printf("Ultimo elemento usando a formula generica: matriz[%d][%d][%d] = %2d\n", 3, 2, 1,
        (*(pInt + 3 * 6 + 2 * 2 + 1)));
    printf("Ultimo elemento considerando matriz 4x6: matriz[%d][%d] = %2d\n",
        3, 5, (*p4x6)[3][5]);
    printf("Ultimo elemento considerando matriz 8x3: matriz[%d][%d] = %2d\n",
        7, 2, (*p8x3)[7][2]);
    printf("Ultimo elemento considerando vetor de 24: matriz[%d] = %2d\n",
        23, (*p24)[23]);

    printf("\n\n\tMudando as dimensoes da mesma matriz:\n\n");
    mostra_vetor_1(24, pInt, "\nUma unica dimensao, 24 elementos");
    mostra_vetor_2(4, 6, (int*)p4x6, "\nDuas dimensoes, 4x6");
    mostra_vetor_2(8, 3, (int*)p8x3, "\nDuas dimensoes, 8x3");
    mostra_vetor_3(4, 3, 2, (int*)p4x3x2, "\nTres dimensoes, 4x3x2");
    return 0;
}


int 	mostra_vetor_1(int N, int* V, const char* msg)
{
    if (msg != NULL) printf("%s\n", msg);
    printf("Vetor[%d]:\n[ ", N);
    for (int i = 0; i < N - 1; i += 1) printf("%2d,  ", V[i]);
    printf("%2d ]\n\n", V[N - 1]);
    return 0;
};


int 	mostra_vetor_2(int M, int N, int* V, const char* msg)
{
    if (msg != NULL) printf("%s\n", msg);
    printf("Vetor[%d][%d]:\n[\n", M, N);
    for (int l = 0; l < M; l += 1)
    {
        printf("\t[ ");
        for (int c = 0; c < N - 1; c += 1)
        {
            printf("%2d, ", *(V + l * N + c));
        }
        printf("%2d ]\n", *(V + l * N + N - 1));
    }
    printf("]\n");
    return 0;
};


int 	mostra_vetor_3(int M, int N, int O, int* V, const char* msg)
{
    if (msg != NULL) printf("%s\n", msg);
    printf("Vetor[%d][%d][%d]:\n[\n", M, N, O);
    for (int p = 0; p < M; p += 1)
    {   // plano p
        printf("\t[\n");
        for (int l = 0; l < N; l += 1)
        {   // linha l
            printf("\t\t[ ");
            for (int c = 0; c < O - 1; c += 1)
            {   // coluna c
                printf("%2d, ", *(V + p * N * O + l * O + c)); // a mesma formula
            }
            printf("%2d ]\n", *(V + p * N * O + l * O + O - 1));
        }
        printf("]\n");
    };
    printf("]\n\n");
    return 0;
};

// fim de main

 

TL;DR
 

:) Eu usava coisas assim em entrevistas de teste para estagiários e analistas

O importante era a pessoa entender, ou no mínimo saber explicar essas declarações

 

    int                      matriz[4][3][2];
    int(*p4x3x2)[4][3][2] = (int(*)[4][3][2]) matriz;
    int(*p4x6)[4][6] =      (int(*)[4][6]) matriz;
    int(*p8x3)[8][3] =      (int(*)[8][3]) matriz;
    int(*p24)[24] =         (int(*)[24]) matriz;

 

E entender a fórmula em uso aqui
 

            printf("\t\t[ ");
            for (int c = 0; c < O - 1; c += 1)
            {   // coluna c
                printf("%2d, ", *(V + p * N * O + l * O + c)); // a mesma formula
            }
            printf("%2d ]\n", *(V + p * N * O + l * O + O - 1));

 

e aqui

 

        for (int c = 0; c < N - 1; c += 1)
        {
            printf("%2d, ", *(V + l * N + c));
        }
        printf("%2d ]\n", *(V + l * N + N - 1));
    }

 

no programa acima.  E quem sabe escrever a função genérica que o compilador usa e usar uma função mostra_x genérica...

 

Claro, a mesma do livro de Tenenbaun e outros, como citado em outro tópico acima.

 

 

Em 05/05/2021 às 19:17, Kyul disse:

Caso queira criar um cópia para não alterar a matriz original, você deve, obrigatoriamente, mexer com ponteiros duplos

 

Não, não é o caso. apenas base e deslocamento a menos que você tenha construído a tal matriz usando vetores de ponteiros e aí não vai poder contar com nada do compilador.

 

Em 05/05/2021 às 22:27, Kyul disse:

Logo, neste caso, nós podemos enxergar os arrays como ponteiros e vice-versa.

Porém, não é possível mudar o endereço no qual um array aponta.

 

Coisas assim ficam rapidamente confusas para um iniciante que leia isso. Arrays não apontam para nada. E não se pode enxergar um ponteiro como um array. Um ponteiro é apenas um endereço e pode ser apenas isso.

 

char**** por exemplo pode ser um arquivo csv. Ou nada. Ou um arquivo texto. Tudo depende de como for construído. char** argv é um vetor de strings em C sempre, mas é assim porque o compilador cria isso bem certinho para cada programa.

 

Link para o post
Compartilhar em outros sites

Crie uma conta ou entre para comentar

Você precisa ser um usuário para fazer um comentário

Criar uma conta

Crie uma nova conta em nossa comunidade. É fácil!

Crie uma nova conta

Entrar

Já tem uma conta? Faça o login.

Entrar agora

Sobre o Clube do Hardware

No ar desde 1996, o Clube do Hardware é uma das maiores, mais antigas e mais respeitadas comunidades sobre tecnologia do Brasil. Leia mais

Direitos autorais

Não permitimos a cópia ou reprodução do conteúdo do nosso site, fórum, newsletters e redes sociais, mesmo citando-se a fonte. Leia mais

×
×
  • Criar novo...

Redes-Wi-Fi-capa-3d-newsletter.png

EBOOK GRÁTIS!

CLIQUE AQUI E BAIXE AGORA MESMO!