Besoin d'aide c++

#include <iostream>
#include <math.h>  // Ici j'ai enlevé les librairies inutiles
#define N 4
typedef double Vecteur[N];
typedef double Matrice[N][N];


/* Là j'enlève le "using namespace std",
il faut mettre "std::" devant tous les cin, cout et endl ; c'est mieux
*/
double norme(Vecteur V)
{

//...


int main()
{
    Matrice A;
    for (int i=1 ; i < N ; i++) // juste < N et pas <= N
    {

 /* idem, sinon le programme se crash en tentant d&#8217;accéder à des éléments qui ne sont pas alloués : */

        for (int j=1 ; j < N ; j++)
        {
            if (j==i)
                A[i][j]=2*(N-1);
            else if (j==i+1)    /*Ici je change les "if" en "else if", c'est plus sûr, 
car si j ou i venait à être modifié dans la condition précédente, 
celle-ci ou une autre risquerait de s'executer aussi.
De plus le else à la fin ne s'appliquait avant qu'au "if" le précédent,
et je suis pas convaincu que se soit ce que tu veuilles faire. */
                A[i][j]=-1*(N-1);
            else if (j==i-1)
                A[i][j]=-1*(N-1);
            else
                A[i][j]=0.0;
        }
    }

// Là comme il n'y a plus using namespace on rajoute les std::
    std::cout<<"------------------------------------------------------------------------"<<std::endl;
    std::cout<<"----------------------METHODE D'UZAWA---------------------------------- "<<std::endl;
    std::cout<<"-------------------------------------------------------------------------"<<std::endl;



}

#include <iostream>
#include <math.h>

int main (int argc,char **argv)
{

    const int N=4;  // N =  4;

    double h = (1/(N-1));  // h = (1/(N-1)) soit 1/3;
    double A[N][N] = {0};  // A = zeros(N,N);

    for (int i = 0; i < N; i++ ) //for i = 1:N
    {
        for (int j = 0; j < N; j++) //for j = 1:N
        {
            if (j == i) //if (j==i) then
            {
                A[i][j] = 2; // A(i,j)=2;
            } //end
            else if (j == (i+1)) // if (j== i+1)
            {
                A[i][j] = - 1; //then A(i,j)=-1; end
            }
            else if (j == (i-1)) //if (j== i-1)
            {
                A[i][j] = -1; //   then A(i,j)=-1; end
            }
        } //end;
    }//end;

//******disp ('afficher la matrice', A); ******/
    std::cout << "`\nMatrice A : \n";
    for (int y = 0; y < N; y++)
    {
        for (int x = 0; x < N; x++)
        {
            std::cout << A[x][y] << " - ";
        }
        std::cout << std::endl;
    }
//********************************************/



//***** A =  (1/h)*A ; *****/
    for (int y = 0; y < N; y++)
    {
        for (int x = 0; x < N; x++)
        {
            A[x][y] *= (1/h);
        }
    }
//***************************/



    double F[N] = {h}; //F=h*ones(N,1)

    double B[2][N] = {0}; //B=zeros(2,N);
    B[0][0] = 1; //B(1,1)=1;
    B[1][1] =1; //B(2,2)=1;
    B[0][N - 1] = -1; //B(1,N)=-1;
    B[1][N-2] = -1; //B(2,N-1)=-1;


    double T[N+1] = {0}; //T=zeros(1,N+2);

    double k[N+2][N+2] = {0}; //k=zeros(N+2,N+2);
// ? // k=[A,B';B,[0 0;0 0]]

//*****T=[F;0;0]*****/
    for (int z = 0; z < N - 2; z ++)
    {
        T[z] = h;
    }
//*********************/
// ? // S=linsolve(k,-T)

    double rho = pow(10,-3); //rho=10^(-3);
    double eps = pow(10, -6); //eps=10^(-6);
    double u[N] = {rand()};  // u=rand(zeros(N,1));
    double p[2] = {rand()}; // p=rand(zeros(2,1));
    int nmmax = 10000; //nmax=10000

// ? // function[p1,u1,n]=Uzawa(u,p,A,B,F,nmax,eps,rho)

//******p1=p;*****/
    double p1[2];
    for (int z = 0; z < N;z++)
    {
        p1[z] = p[z];
    }
//********/


    for (int n = 1; n < nmmax; n++) //for n=1:nmax
    {
        double d[N];

//*****d=F-B'*p1; ***/
        for (int z = 0; z < N; z++)
        {
            d[z] = F[z] - B[0][z]; // ?
        }
//*******************/


//********u=inv (A)*d;*****/
        for (int z = 0; z < N; z++)
        {
            u[z] = (1 / (A[z][z])) * d[z]; // ?
        }
//**************************/

        double p2[2];

        //******p2=p1+rho*B*u;****/
        for (int z = 0; z < 2; z++)
        {
            p2[z] = p1[z] + rho * B[0][z] * u[z];
        }
//***************/

        if (sizeof(p2) - sizeof(p1) < eps)  //if (norm(p2-p1))<eps then
        {
            return 0; //return
        } //end
//******p1=p2;*****/
        double p1[2];
        for (int z = 0; z < N;z++)
        {
            p1[z] = p2[z];
        }
//********/

    }//end

//*****u1=u****/
    double u1[N];
    for (int z = 0; z < N;z++)
    {
        u1[z] = u[z];
    }
//*******/

//endfunction

//[p1,u1,n]=Uzawa(u,p,A,B,F,nmax,eps,rho); ?


    std::cout << "La solution 1 est p1" << p1 << "\n"; //mprintf('la solution 1 est \n') p1
    std::cout << "La solution 2 est p1" << u1 << "\n";  //mprintf('la solution 2 est \n') u1

    return 0;
}