Duvida de C++

Acho que o problema é declarares a variavel c como um array bidimensional de apontadores e depois chamares esta função com &D (array de uma dimensão).

O melhor é esperares por outra resposta, mas acho que é este o problema.

Cumps

 

Experimenta declarar *c na função como sendo um array de uma dimensão, mas se calhar também não deve dar, porque &d é apenas um endereço de uma variável e *c é um array de apontadores.

Se calhar é melhor mostrares mais um pouco do teu código para ver se percebo a tua ideia para fazer o programa.


Cumps

 

O programa só tem de funcionar com matrizes 2 por 2?
É que para determinantes de 2ª ordem tens a regra dos produtos cruzados.

 

Não devias ter uma classe matrix?

 

Se fosse até 3x3 também havia regra.
Acho que não estou a perceber muito bem o que pretendes...dizes que queres fazer trocar um vector na coluna da matriz copia...o quê que queres dizer com isto??

Pretendes trocar duas colunas ou duas linhas é isso?

Eu vou tentar ajudar-te o que puder, mas aviso-te que também não sei assim muito de c++.

 

Experimenta assim

Código:

void trocar_coluna (int c,int d, float b[4], float &C[4][4])
{
    int l;
                    for(l=0;l<d;l++) C[l][c] = b[l];
}

E depois chamas assim

trocar_coluna(0,2,B,D);

Estás a passar uma referência de um array bidimensional, e alterando a referencia altera também o valor da variável D quando chamas a função.

 

Umas referencias:

- A função main deve retornar um inteiro. É uma boa prática.
- A biblioteca stdio é de C, e não de C++. Deves incluir iostream se quiseres fazer output, e ter using namespace std;
- A tua função troca coluna não precisa de retornar um float, visto que o que tu estás a fazer é a tentar alterar o valor do array que recebes como argumento.

Aqui estão uns apontamentos interessantes sobre apontadores: http://psantos.zi-yu.com/wiki.aspx?topic=PRE.Refer%C3%AAnciasApontadores

edit: agora não posso testar, mais logo faço isso

 

Código:

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

struct matrix
{
    size_t row_size;
    size_t column_size;
    
    double* matrix;
};

struct matrix* matrix_create(
    size_t row_size,
    size_t column_size,
    const double* matrix)
{
    struct matrix* new_matrix = (struct matrix*) malloc(sizeof(struct matrix));
    new_matrix->row_size      = row_size;
    new_matrix->column_size   = column_size;
    new_matrix->matrix        = (double*) malloc(sizeof(double)
                                                 * row_size
                                                 * column_size);
    memcpy(new_matrix->matrix, matrix, sizeof(double) * row_size * column_size);
    return new_matrix;
}

void matrix_swap_columns(struct matrix* matrix, size_t to, size_t from) {
    double temp;
    size_t i;
    double* from_pointer = matrix->matrix + from;
    double* to_pointer = matrix->matrix + to;
    for(i = 0; i < matrix->row_size; ++i)
    {
        temp = *from_pointer;
        *from_pointer = *to_pointer;
        *to_pointer = temp;
        from_pointer += matrix->column_size;
        to_pointer += matrix->column_size;
    }
    
    
}

void matrix_destroy(struct matrix* matrix_to_destroy) {
    free(matrix_to_destroy->matrix);
    free(matrix_to_destroy);
}

void matrix_print(const struct matrix* matrix) {
    putchar('[');
    size_t i;
    for(i = 0; i < matrix->row_size; ++i)
    {
        putchar('[');
        size_t j;
        for(j = 0; j < matrix->column_size; ++j)
        {
            printf("%f ", *((matrix->matrix) + j + i * matrix->column_size));
        }
        putchar(']');
        putchar('\n');
    }
    putchar(']');
}

int main ()
{
    double temp[] = {1, 2, 3, 4, 20, 40, 50, 100, 255, 266, 201, 21};
    struct matrix* test = matrix_create(3, 4, temp);
    matrix_swap_columns(test, 2, 3);
    matrix_print(test);
    matrix_destroy(test);
    return 0;
}

Talvez isto ajude. Odeio C++ .

 

Bem me parecia que não estava a ver bem a coisa. O problema é que tu estás a tentar passar um apontador de um array, e isso não é possível da maneira que estás a fazer.

Código:

#include <iostream>

using namespace std;

void trocar_coluna (int c,int d, float b[4], float *C)
{
    int l;

    for(l=0;l<10;l++)
        ++C;

    //quando l for 9, C foi incrementado 9 vezes (o elemento numero 11 passa a 300)
    *C = 300;


}
int main()
{
    float D[4][4],A[4][4],B[4];                    
    //D[4][4]=A[4][4];
    float D1[4][4] = {{1, 2, 3, 4}, {5, 6, 7, 8}, {9, 10, 11, 12}, {13, 14, 15, 16}};

    cout << "antes de o elemento ser alterado" << endl;
    for (int i = 0; i != 4; i++) {
        for (int j = 0; j != 4; j++)
            cout << D1[i][j] << endl;
    }

    cout << endl << endl;

    cout << "depois do elemento ser alterado" << endl;
    trocar_coluna(0,2,B,&D1[0][0]);

    for (int i = 0; i != 4; i++) {
        for (int j = 0; j != 4; j++)
            cout << D1[i][j] << endl;
    }
    return 0;

}

Espero que isto te ajude a compreender. Tens de passar um apontador para o primeiro elemento do array (C é um apontador para a posição 0, 0 do array D1), e depois para acederes a outros elementos vais incrementando o apontador de forma a ele apontar para outras posições do array.


Agora só tens de adaptar ao teu programa. Se tiveres alguma dúvida, diz.