Inna zwracana wartość w zależności od kompilatora.

0

Napisałam program początkowo w Visual Studio Code, jednak tam mam problem z debuggerem i w miedzy czasie poprawiałam go w internetowych kompilatorach. W Visual Studio Code program zwraca wartość -2, czyli błędną, jednak w internetowych kompilatorach program działa poprawnie, czyli zwraca wartość -3. Dopiero zaczynam programować i nie wiem jaki jest problem.



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


typedef struct 
{
    int rows;
    int columns;
    int *ptr;
}matrix;

matrix creatematrix(int rows, int columns)
{
    int *ptr=calloc(rows*columns, sizeof(int));
    return (matrix) {rows, columns, ptr};
}

matrix cut(matrix A, int row, int column)
{
    matrix new=creatematrix(A.rows-1, A.columns-1);
    for (int i=0; i<new.rows; i++)
    {
        int z=(i+1)*A.columns+column;

        for (int j=0; j<=new.columns; j++)
        {
            int k=(i+1)*A.columns+j;
            if (k+1==z)
            continue;
            else
            {
            *new.ptr=*(A.ptr+k);
            new.ptr++;
            }
        }
    }


    for (int w=0; w<new.columns*new.columns; w++)
    {
        new.ptr--;
    }
    return new;
}

void printmatrix( matrix A, int n)
{
    for (int i=0; i<n; i++)
    {
        for (int j=0; j<n; j++)
        {
            printf("%d ", *A.ptr++);
        }
        printf("\n");
    }
}

int determinantfff(matrix A)
{
    int determinant;
    if (A.columns==2)
    {
        int fi = *(A.ptr);
        int se = *(A.ptr+1);
        int th = *(A.ptr+2);
        int fo = *(A.ptr + 3);
        determinant= (fi*fo)-(se*th);
    }
    else
    {
        for (int x=0; x<A.columns; x++)
        {
            matrix Z = creatematrix(A.columns-1, A.rows-1);
            Z=cut(A,1,x+1);
            int www = determinantfff(Z);
            int smalldeterminant=*(A.ptr+x)*www;
            if ((x+1)%2==0)
            {
                determinant=determinant-smalldeterminant;
            }
            else
            {
                determinant=determinant + smalldeterminant;
            }
        }
    }

return determinant;
}




int main()
{
    matrix A= creatematrix (3,3);
    memcpy (A.ptr, (int [9]) {1,2,3,4,5,6,7,8,10}, sizeof(int [9]));
    int determinantA=determinantfff(A);

    printf("Determinant is: %d\n", determinantA);
    free(A.ptr);
    return 0;

}
0

Znalazłam swój błąd, wystarczyło przy inicjalizowaniu dodać "int determinant=0;"

2

Bosch ... tu roi się od warningów.
Jedziesz po Undefined Behaviour, to i masz niestabilne wyniki.

A rzutowanie wyłącza jeden z nich.

a) rzutowanie niekompatybilnych (nie zawsze kompatybilnych) danych
b) zwracanie obszaru pamięci ze stosu, który już chwilę później nie jest ważny. Lada chwila zostanie zamazany

ps. Wydaje ci się, ze znalazłaś błąd i uczyniłaś kod bezbłędnym.
c) dekrementowanie/inkrementowanie wskaźnika, który będzie zwalniany
W tym punkcie - nie używaj pseudohakerskiej arytmetyki wskaźnikowej, tylko notacji tablicowej.

d) czy nie przejeżdżasz zakresu to nie czytam.

Włos się jeży na ten kod.

Włączyć ostrzeżenia i je czytać !!! (ale nie wszystko będzie podane)

Co do pomysłu "programowania obiektowego" w C. Niby można, kiedyś tak robiłem.
Jeśli to musi być w C, jak masz pseudo-kontruktor, to napisz pseudo-destruktor.
Napisz też więcej pseudo-metod, a nie operuj z main() na zmiennych wewnętrznych

1 użytkowników online, w tym zalogowanych: 0, gości: 1