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

Moraes_27 · 4 de maio de 2021

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.

devair1010 · 5 de maio de 2021

@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 .

Kyul · 5 de maio de 2021

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.

kgin · 5 de maio de 2021

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.

arfneto · 6 de maio de 2021

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.

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.

Kyul · 6 de maio de 2021

@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.

arfneto · 6 de maio de 2021

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.

Kyul · 6 de maio de 2021

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.

arfneto · 7 de maio de 2021

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.