Usuwanie niepotrzebnych klamer

Witam, chciałbym w ramach praktyki pousuwać niepotrzebne klamre, wiem, ze jak jest 1 instrukcja pod pętlą to klamre nie są potrzebne, ale tutaj kod jest dość bardziej zawiły, pomoglby mi ktos? Wiem, ze kod bedzie wtedy mało czytelny, ale po prostu chodzi mi o praktykę i ogarniecie róznych mozliwosci zapisu c++

void fun(string f, float a,float h,int M)
{
    float** D = new float*[M+2];
    float dh;
    for(int i = 0; i < (M+2); ++i)
    {
        D[i] = new float[M+2];
    }

    for(int i = 0; i <= (M+1); ++i)
    {
        for(int j = 0; j <= (M+1); ++j)
        {
            D[i][j]=0.0;
        }
    }

     for(int n = 0; n <= M; ++n)
    {
        dh = h/(pow(2, n));
        D[n+1][1] = (gm(f, a+dh)-feval(f, a-dh))/(2*dh);
    }

    for(int k = 1; k <= M; ++k)
    {
        for(int n = k; n <= M; ++n)
        {
            if((4^k-1) == 0)
            {
                D[n+1][k+1] = D[M][k];
            }else
            {
                D[n+1][k+1]=D[n+1][k]+(D[n+1][k]-D[n][k])/(pow(4, k)-1);
            }

        }

    }

    cout << setprecision(4) <<fixed;
    for(int i = 1; i <= (M+1); ++i)
    {
        for(int j = 1; j <= (M+1); ++j)
        {
            cout<<D[i][j]<<" ";
        }
        cout<<endl;
    }


}

Martwisz się o usuwanie klamer, a masz tutaj większy problem z wyciekiem pamięci. Nigdzie nie usuwasz obiektów utworzonych za pomocą operatora new.

W każdym projekcie ustala się coding conventions.
Większość coding conventions wymaga klamer dla każdego for if i else nieważne czy zawiera jedną czy więcej instrukcji.

Uncle Bob ma inny coding standard, w którym w ogóle nie ma klamer dla for if i else. W jego sposobie kodowania: każdy warunek wewnątrz if, każdy branch dla for if i else to wywołanie jednej konkretnej funkcji (choćby napisanej tylko dla tego jednego użytku).

Cokolwiek jest ustalone w projekcie masz przestrzegać.

martwisz się o jakieś bzdury, a brakuje ci umiejętności w podstawach.

• if((4^k-1) == 0) WAT? Nie wiem co zamierzałeś ale to działa tak samo jak: if(k == 5)
• pochrzaniłeś zakres indeksów
• wspomniany wyżej wyciek: https://dsp.krzaq.cc/post/176/ucze-sie-cxx-kiedy-uzywac-new-i-delete
• pow(4, k) operuje na liczbach zmiennoprzecinkowych ergo możesz mieć dziwne problemy zaokrągleń.
• twoja funkcja robi za dużo (coś liczy, "nie zarządza" pamięcią i wypisuje dane).
• nazwa funkcji jest bezsensu, co to ma robić?

Lepiej nie usuwaj klamer. Zwłaszcza jak jesteś początkujący.
Może się zdarzyć, że dopiszesz instrukcję do "bloku kodu" i się będziesz dziwić, że nie wykonuje się ona w pętli itd.

Chciałem zobaczyc jak ten kod bedzie wygladał bez niepotrzebnych klamer :D

@dcielak:

void fun(string f, float a,float h,int M)
{
    float** D = new float*[M+2];
    float dh;

    for(int i = 0; i < (M+2); ++i)
        D[i] = new float[M+2];

    for(int i = 0; i <= (M+1); ++i)
    {
        for(int j = 0; j <= (M+1); ++j)
            D[i][j]=0.0;
    }

     for(int n = 0; n <= M; ++n)
    {
        dh = h/(pow(2, n));
        D[n+1][1] = (gm(f, a+dh)-feval(f, a-dh))/(2*dh);
    }

    for(int k = 1; k <= M; ++k)
    {
        for(int n = k; n <= M; ++n)
        {
            if((4^k-1) == 0)
                D[n+1][k+1] = D[M][k];
            else
                D[n+1][k+1]=D[n+1][k]+(D[n+1][k]-D[n][k])/(pow(4, k)-1);
        }

    }

    cout << setprecision(4) <<fixed;

    for(int i = 1; i <= (M+1); ++i)
    {
        for(int j = 1; j <= (M+1); ++j)
            cout<<D[i][j]<<" ";

        cout<<endl;
    }
}

Ten feval wygląda jakbyś chciał koniecznie udawać matlaba. To 4^k to w sumie też wieje matlabem. Czemu nie po prostu wskaźnik na funkcję zamiast fevala?

void fun(string f, float a,float h,int M)
{
    float** D = new float*[M+2];
    float dh;
    for(int i = 0; i < (M+2); ++i)
        D[i] = new float[M+2];

    for(int i = 0; i <= (M+1); ++i)
        for(int j = 0; j <= (M+1); ++j)
            D[i][j]=0.0;

     for(int n = 0; n <= M; ++n)
    {
        dh = h/(pow(2, n));
        D[n+1][1] = (gm(f, a+dh)-feval(f, a-dh))/(2*dh);
    }

    for(int k = 1; k <= M; ++k)
        for(int n = k; n <= M; ++n)
            if((4^k-1) == 0)
                D[n+1][k+1] = D[M][k];
            else
                D[n+1][k+1]=D[n+1][k]+(D[n+1][k]-D[n][k])/(pow(4, k)-1);

    cout << setprecision(4) <<fixed;
    for(int i = 1; i <= (M+1); ++i)
    {
        for(int j = 1; j <= (M+1); ++j)
            cout<<D[i][j]<<" ";
        cout<<endl;
    }

}

Jeszcze o jednym nikt nie wspomniał:
(4^k-1) == 0 oraz /(pow(4, k)-1) podejrzewam że to dodano aby przez zero nie dzielić :)
operacja a^b to xor, nie potęga.