Iniciar sesiónCerrar
Correo:
Contraseña:
Entrar
Recordar sesión en este navegador
Iniciar sesiónIniciar sesiónCrear cuentaCrear cuenta
LWP » Foros » Dev - C++ » error: cannot convert "int (*)[c]" to "int*" for argument "1"

Dev - C++ - error: cannot convert "int (*)[c]" to "int*" for argument "1"

Volver
Nuevo Tema
<<>>
 
Vista:
sin imagen de perfil

error: cannot convert "int (*)[c]" to "int*" for argument "1"

Publicado por Elena (3 intervenciones) el 18/11/2018 22:08:23
Estoy intentando hacer un programa con ficheros y arrays donde se muestren matrices, se rellenen, se calcule la suma, el producto por escalar y el producto entre dos matrices, y el compilador me da el siguiente error:


error: cannot convert 'int (*)[c]' to 'int*' for argument '1' to 'void RellenarMatrices(int*, int)'|

Os dejo el codigo a ver si me podeis ayudar.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
#include <iostream>
#include "matrices.hpp"
using namespace std;
 
int main()
{
    int f, c, escalar, prodescalar;
    int a[f][c], b[f][c], r[f][c], s[f][c], p[f][c];
 
    cout << "Introduzca el numero de filas de las matrices: ";
    cin >> f;
    cout << "Introduzca el numero de columnas de las matrices: ";
    cin >> c;
    cout << "Introduzca un escalar: ";
    cin >> escalar;
 
    RellenarMatrices(a, f, c);
    RellenarMatrices(b, f, c);
    MostrarMatrices(a, f, c);
    MostrarMatrices(b, f, c);
    prodescalar = ProductoMatrizEscalar(a, r, f, c, escalar);
    s = SumaMatrices(a, b, s, f, c);
    p = ProductoMatrices(a, b, p, f, c, c);
 
 
    cout << "La suma es: " << MostrarMatrices(s, f, c) << endl;
    cout << "El producto por el escalar " << escalar << "es: " << MostrarMatrices(r, f, c) << endl;
    cout << "El producto de las dos matrices es: " << MostrarMatrices(p, f, c) << endl;
 
    return 0;
}


Las funciones están aquí:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
#include "matrices.hpp"
 
/**Calcular el producto de una matriz por un escalar**/
 
void ProductoMatrizEscalar(int a[][100], int r[][100], int f, int c, int escalar)
{
    int i, j;
    for(i=0; i<f; i++)
        for(j=0; j<c; j++)
        r[i][j] = escalar*a[i][j];
 
        return;
 
}
 
/**Calcular la suma de dos matrices**/
 
void SumaMatrices(int a[][100], int b[][100], int r[][100], int f, int c)
{
    int i, j;
    for(i=0; i<f; i++)
        for(j=0; j<c; j++)
        r[i][j] = a[i][j] + b[i][j];
 
    return;
}
 
/**Calcular el producto de dos matrices**/
 
void ProductoMatrices(int a[][100], int b[][100], int r[][100], int f1, int c1, int c2)
{
    int i, j, k;
    for(i=0; i<f1; i++)
        for(j=0; j<c1; j++)
        {
        r[i][j] = 0;
        for(k=0; k<c2; k++)
        r[i][j] = a[i][k]*b[k][j];
        }
 
        return;
 
}
 
/**Rellenar matrices**/
 
void RellenarMatrices(int m[][100], int nfils, int ncols)
{
    int i, j;
    for(i=0; i<nfils; i++)
        for(j=0; j<ncols; j++)
    {
        cout << "Elemento [" << i+1 << "," << j+1 << "]: ";
        cin >> m[i][j];
    }
 
    return;
}
 
/**Mostrar matrices**/
 
void MostrarMatrices(int m[][100], int nfils, int ncols)
{
    int i, j;
    for(i=0; i<nfils;  i++)
        for(j=0; j<ncols; j++)
    {
        cout << "Elemento [" << i+1 << "," << j+1 << "]: ";
        cout << m[i][j] << endl;
    }
 
    return;
}


Solo me da error en la primera parte, dentro del int main, en lo demás no.

Gracias.
Valora esta pregunta
Me gusta: Está pregunta es útil y esta claraNo me gusta: Está pregunta no esta clara o no es útil
0
Responder
sin imagen de perfil
Val: 338
Ha mantenido su posición en Dev - C++ (en relación al último mes)
Gráfica de Dev - C++

error: cannot convert "int (*)[c]" to "int*" for argument "1"

Publicado por Martín (158 intervenciones) el 19/11/2018 13:25:14
Hay dos errores importantes.

El primero es que en C++ no se permiten los arrays de estilo C de dimensiones variables (se les dice VLA - "Variable Length Array").
1
2
int f, c;  // f y c son variables

int a[f][c],
en C es válido pero en C++ no. Puede ser que algún compilador lo acepte como "extensión al lenguaje", pero a no ser que estés muy seguro de que estás usando esa extensión particular de tu compilador particular, más vale no usarla.

Otro error es que el mensaje de error no se corresponde con el código que muestras.
1
error: cannot convert 'int (*)[c]' to 'int*' ... etcétera
mientras que en el código que muestras la función recibe eso mismo. Raro, revisa eso.
Valora esta respuesta
Me gusta: Está respuesta es útil y esta claraNo me gusta: Está respuesta no esta clara o no es útil
0
Comentar
sin imagen de perfil

error: cannot convert "int (*)[c]" to "int*" for argument "1"

Publicado por Elena (3 intervenciones) el 19/11/2018 21:11:45
¿Y cómo lo arreglo?
Valora esta respuesta
Me gusta: Está respuesta es útil y esta claraNo me gusta: Está respuesta no esta clara o no es útil
0
Comentar
sin imagen de perfil

error: cannot convert "int (*)[c]" to "int*" for argument "1"

Publicado por Elena (3 intervenciones) el 19/11/2018 21:38:20
Ahora lo he hecho de esta manera:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
#include <iostream>
#include "matrices.hpp"
#define MAX 100
using namespace std;
 
int main()
{
    int f, c, escalar, prodescalar;
    int a[][MAX], b[][MAX], r[][MAX], s[][MAX], p[][MAX];
 
    cout << "Introduzca el numero de filas de las matrices: ";
    cin >> f;
    cout << "Introduzca el numero de columnas de las matrices: ";
    cin >> c;
    cout << "Introduzca un escalar: ";
    cin >> escalar;
 
    RellenarMatrices(a, f, c);
    RellenarMatrices(b, f, c);
    MostrarMatrices(a, f, c);
    MostrarMatrices(b, f, c);
    prodescalar = ProductoMatrizEscalar(a, r, f, c, escalar);
    s = SumaMatrices(a, b, s, f, c);
    p = ProductoMatrices(a, b, p, f, c, c);
 
 
    cout << "La suma es: " << MostrarMatrices(s, f, c) << endl;
    cout << "El producto por el escalar " << escalar << "es: " << MostrarMatrices(r, f, c) << endl;
    cout << "El producto de las dos matrices es: " << MostrarMatrices(p, f, c) << endl;
 
    return 0;
}

Y me sale el siguiente error:

error: storage size of 'a' isn't known| en la línea 9 para todos los arrays que he declarado. ¿Me ayudas?
Valora esta respuesta
Me gusta: Está respuesta es útil y esta claraNo me gusta: Está respuesta no esta clara o no es útil
0
Comentar
sin imagen de perfil
Val: 417
Ha mantenido su posición en Dev - C++ (en relación al último mes)
Gráfica de Dev - C++

error: cannot convert "int (*)[c]" to "int*" for argument "1"

Publicado por Thanatos (199 intervenciones) el 20/11/2018 17:46:20
matrices.hpp
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
#ifndef MATRICES_HPP
#define MATRICES_HPP
 
#include <cstddef>  // size_t

 
void sumaMatrices(
    int *const *, int *const *, int *const *, const size_t, const size_t
);
 
void productoMatrizEscalar(
    int *const *, int *const *, const int, const size_t, const size_t
);
 
void productoMatrices(
    int *const *, int *const *, int * const*, const size_t, const size_t
);
 
void rellenarMatriz(int *const *, const size_t, const size_t);
void mostrarMatriz(int *const *, const size_t, const size_t);
 
int **reservarMemoria(const size_t, const size_t);
void liberarMemoria(int **, const size_t);
 
#endif

matrices.cpp
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
#include "matrices.hpp"
#include <iostream>
#include <iomanip>  // setw()

 
void sumaMatrices(int *const *matA,
                   int *const *matB,
                   int *const *matR,
                   const size_t fils,
                   const size_t cols) {
    for (size_t i = 0; i < fils; ++i) {
        for (size_t j = 0; j < cols; ++j) {
            matR[i][j] = matA[i][j] + matB[i][j];
        }
    }
}
 
void productoMatrizEscalar(int *const *mat,
                           int *const *matR,
                           const int escalar,
                           const size_t fils,
                           const size_t cols) {
    for (size_t i = 0; i < fils; ++i) {
        for (size_t j = 0; j < cols; ++j) {
            matR[i][j] = escalar * mat[i][j];
        }
    }
}
 
void productoMatrices(int *const *matA,
                      int *const *matB,
                      int *const *matR,
                      const size_t fils,
                      const size_t cols) {
    for (size_t i = 0; i < fils; ++i) {
        for (size_t j = 0; j < cols; ++j) {
            int suma = 0;
            for (size_t k = 0; k < cols; ++k) {
                suma += matA[i][k] * matB[k][j];
            }
            matR[i][j] = suma;
        }
    }
}
 
void rellenarMatriz(int *const *mat, const size_t fils, const size_t cols) {
    for (size_t i = 0; i < fils; ++i) {
        for (size_t j = 0; j < cols; ++j) {
            std::cout << "Elemento [" << i + 1 << ", " << j + 1 << "]: ";
            std::cin >> mat[i][j];
        }
    }
    std::cout << '\n';
}
 
void mostrarMatriz(int *const *mat, const size_t fils, const size_t cols) {
    for (size_t i = 0; i < fils; ++i) {
        for (size_t j = 0; j < cols; ++j) {
            std::cout << std::setw(5) << mat[i][j];
        }
        std::cout << '\n';
    }
    std::cout << '\n';
}
 
int **reservarMemoria(const size_t fils, const size_t cols) {
    int **mat = new int *[fils];
 
    for (size_t i = 0; i < fils; ++i) {
        mat[i] = new int[cols];
    }
 
    return mat;
}
 
void liberarMemoria(int **mat, const size_t fils) {
    for (size_t i = 0; i < fils; ++i) {
        delete [] mat[i];
    }
    delete mat;
}

main.cpp
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
#include "matrices.hpp"
#include <iostream>
 
using std::cout;
using std::cin;
 
int main() {
    size_t fils;
    size_t cols;
    int escalar;
 
    cout << "Ingrese el numero de filas de las matrices: ";
    cin >> fils;
 
    cout << "Ingrese el numero de columnas de las matrices: ";
    cin >> cols;
 
    cout << "Ingrese un escalar: ";
    cin >> escalar;
 
    int **matA = reservarMemoria(fils, cols);
    int **matB = reservarMemoria(fils, cols);
    int **matR = reservarMemoria(fils, cols);
    int **matS = reservarMemoria(fils, cols);
    int **matP = reservarMemoria(fils, cols);
 
    cout << "\nIngrese los elementos de la matriz A:\n";
    rellenarMatriz(matA, fils, cols);
 
    cout << "Ingrese los elementos de la matriz B:\n";
    rellenarMatriz(matB, fils, cols);
 
    mostrarMatriz(matA, fils, cols);
    mostrarMatriz(matB, fils, cols);
 
    cout << "\nLa suma de A + B es:\n";
    sumaMatrices(matA, matB, matR, fils, cols);
    mostrarMatriz(matR, fils, cols);
 
    cout << "El producto de A x " << escalar << " es:\n";
    productoMatrizEscalar(matA, matR, escalar, fils, cols);
    mostrarMatriz(matR, fils, cols);
 
    cout << "El producto de A x B es:\n";
    productoMatrices(matA, matB, matR, fils, cols);
    mostrarMatriz(matR, fils, cols);
 
    liberarMemoria(matA, fils);
    liberarMemoria(matB, fils);
    liberarMemoria(matR, fils);
    liberarMemoria(matS, fils);
    liberarMemoria(matP, fils);
 
    return 0;
}
Valora esta respuesta
Me gusta: Está respuesta es útil y esta claraNo me gusta: Está respuesta no esta clara o no es útil
0
Comentar