Полином манипуляции

Question

Я хочу добавить два полинома и установить результаты на результат полинома. У меня проблема с третьей функцией, пожалуйста, любые указания Мне действительно нужна помощь PS: динамическое объявление! Кажется, я не очень хорошо понимаю указатели, поэтому было бы полезно, если бы вы предложили мне что-нибудь, что может помочь мне понять эту главу, пожалуйста!

     typedef struct {
            int degree;
            float* coeff_tab;
        } Polynome;


        Polynome lire_polynome()
        {
            Polynome p;
            int i;

            printf("Degree du polynome? ");
            scanf("%d", &p.degree);
            p.coeff_tab = (float*)malloc((unsigned long)(p.degree+1)*sizeof (float));

            for(i=0; i<=p.degree; i++)
            {
                printf("coeff de degree %i: ", i);
                scanf("%f", &p.coeff_tab[i]);
            }
            //free(p.coeff_tab);

            return p;
        }


        void affiche_polynome(Polynome p)
        {
            int i;
            if(p.degree > 1){
                printf("%4.2fX^%i ", p.coeff_tab[p.degree], p.degree);
                for(i=p.degree-1; i>1; i--){
                    printf(" + %4.2fX^%i ", p.coeff_tab[i], i);
                }
                printf(" + %4.2fX + %4.2f\n", p.coeff_tab[1], p.coeff_tab[0]);
            } else {
                printf(" + %4.2f\n", p.coeff_tab[0]);
            }
        }
        void sommePoly(Polynome p1 , Polynome p2 , Polynome psom)
 {
     int degsom,deg1,deg2,i=0,j=0,k=0;
     float coeffsum,coeff1,coeff2;
     Polynome *P,*S ,*Psom;
     P=&p1; S=&p2;
     degsom=max(p1.degree,p2.degree);
     psom.coeff_tab=(float*)malloc((unsigned long)(degsom+1)*sizeof (float));
     Psom=&psom;
     if( p1.degree == p2.degree)

     {
        psom.coeff_tab[k]=p1.coeff_tab[i]+p2.coeff_tab[j];
        psom.degree=p1.degree;
        Psom ++;
     i++;j++;k++;
     }
     else if(p1.degree > p2.degree) {
        psom.degree=p1.degree;
        psom.coeff_tab[k]=p1.coeff_tab[i];
        i++;k++;
    }else {
        psom.coeff_tab[k]=p2.coeff_tab[j];
        psom.degree=p2.degree;
        j++;k++;

    }
          }

Answer 1

Я думаю, что эта версия sommePoly - то, что вы ищете:

void sommePoly(Polynome *p1 , Polynome *p2 , Polynome *psom)
{
        int     i;
        Polynome        *big, *sml;

        if (p1->degree > p2->degree) {
                big = p1;
                sml = p2;
        }
        else {
                big = p2;
                sml = p1;
        }

        psom->degree = big->degree;
        psom->coeff_tab = calloc(psom->degree + 1, sizeof(float));

        for (i = 0; i < sml->degree + 1; i++)
        {
                psom->coeff_tab[i] = big->coeff_tab[i] + sml->coeff_tab[i];
        }
        for (; i < big->degree + 1; i++)
        {
                psom->coeff_tab[i] = big->coeff_tab[i];
        }
}

СОВЕТ 1: попробуйте использовать calloc () вместо malloc (). Гораздо безопаснее при попытке выделить любой массив из N элементов размером Z. СОВЕТ 2: И, конечно, всегда проверяйте возвращаемое значение calloc () / malloc () перед разыменованием.

Для иллюстрации предполагаемого использования sommePoly:

void printPoly(Polynome *p)
{
        int     i;
        for (i = p->degree; i > 0; i--) {
                if (0.0 != p->coeff_tab[i])
                        printf("%4.2fX^%i + ", p->coeff_tab[i], i);
        }
        if (0.0 != p->coeff_tab[i])
                printf("%4.2f\n", p->coeff_tab[0]);
}

int main(int argc, char *argv[])
{
        Polynome        a, b, sum;

        a.degree = 5;
        a.coeff_tab = calloc(a.degree + 1, sizeof(float));
        a.coeff_tab[0] =  1.0;
        a.coeff_tab[1] =  8.0;
        a.coeff_tab[2] = -2.0;
        a.coeff_tab[3] =  0.0;
        a.coeff_tab[4] =  3.0;
        a.coeff_tab[5] =  1.0;

        b.degree = 3;
        b.coeff_tab = calloc(b.degree + 1, sizeof(float));
        b.coeff_tab[0] =  1.0;
        b.coeff_tab[1] = -3.0;
        b.coeff_tab[2] =  5.0;
        b.coeff_tab[3] =  7.0;

        sommePoly(&a, &b, &sum);

        printPoly(&a);
        printPoly(&b);
        printPoly(&sum);

        free(a.coeff_tab);
        free(b.coeff_tab);
        free(sum.coeff_tab);

        return 0;
}

и вывод:

$ cc -g -O0 -Wall  poly.c -o poly
$ ./poly
1.00X^5 + 3.00X^4 + -2.00X^2 + 8.00X^1 + 1.00
7.00X^3 + 5.00X^2 + -3.00X^1 + 1.00
1.00X^5 + 3.00X^4 + 7.00X^3 + 3.00X^2 + 5.00X^1 + 2.00

Answer 2

void sommePoly(Polynome p1 , Polynome p2 , Polynome psom)

В C аргументы передаются путем создания копии значения переменной. Итак, p1 - это копия переменной, которую вы передаете. Вам нужно передать указатели, чтобы изменить значения за указателями. Или верните значение, как в случае Polynome lire_polynome().

Обычно я ожидал бы функции:

int lire_polynome(Polynome *p);
int sommePoly(Polynome *p1 , Polynome *p2 , Polynome *psom);

Использование некоторого возвращаемого значения, напр. int вы можете вернуть отрицательное или ненулевое число в случае ошибки (например, malloc error).

То есть ваша функция может выглядеть так:

int sommePoly(Polynome *p1 , Polynome *p2 , Polynome *psom)
{
     int degsom, deg1, deg2, i = 0, j = 0, k = 0;
     float coeffsum, coeff1, coeff2;
     degsom = max(p1->degree, p2->degree);
     psom->coeff_tab = malloc((degsom + 1) * sizeof(float));
     if (psom->coeff_tab == NULL) { return -1; }
     if (p1->degree == p2->degree){
        psom->coeff_tab[k] = p1->coeff_tab[i] + p2->coeff_tab[j];
        psom->degree = p1->degree;
     ... // and so on replace psom. to psom-> ie. replace dot with ->
    }
    return 0;
}

Затем вы называете это передающим указатель на структуры:

Polynome p1;
if (lire_polynome(&p1) != 0) { /* error handling */ }
Polynome p2;
if (lire_polynome(&p2) != 0) { /* error ahdling */ }
Polynome p3;
if (sommePoly(&p1, &p2, &p3) != 0) { /* error handling */ }

1. Не забудьте проверить на scanf ошибки if (scanf("%f", ...) != 1) { fprintf(stderr, "error in scanf"); exit(1); }
2. Не забудьте проверить наличие ошибок malloc.
3. Не разыгрывать результат malloc
4. Приведение к unsigned long в (unsigned long)(p.degree+1)*sizeof (float) странно и довольно подвержено ошибкам. sizeof(...) имеет тип size_t, который является правильным типом для представления размера, приведение его к unsigned long является ненужным и может привести к ошибкам в некоторых случаях большого числа. Просто malloc((p.degree + 1) * sizeof(float)) или calloc(p->degree + 1, sizeof(float));
5. Получите хорошее прочтение о стиле кодирования ядра Linux .
6. Более простой пример передачи указателей и значения модификации можно найти в этой теме .