MATRICE CREUSE matrice creuse, matrix, Matrice 2D, Source N°46651

Information sur la source

Catégorie :Application Classé sous : matrice creuse, matrix, Matrice 2D Niveau : Initié Date de création : 13/05/2008 Date de mise à jour : 16/05/2008 13:29:43 Vu / téléchargé: 1 442 / 34

Auteur : belhauss

Ecrire un message privé

Note :
Aucune note

Commentaire sur cette source (14)

Ajouter un commentaire et/ou une note

Description

une matrice creuse c'est une matrice qui ne stock dans la mémoire que les valeurs non nulle d'une façon dynamique .

Source

#include<conio.h>
#include<stdio.h>
#include<iostream.h>
class noeud;
//////////////////////////////////STRUCT TABLEAU
struct tabs
{
noeud *add;
};
typedef struct tabs tabs;
//////////////////////////////////CLASS MATRICE
class matrice
{
public:
matrice();
int get_nbrLi(void);
int get_nbrCo(void);
void matcreus(int **,tabs *,tabs *);
int lecture_fichier(char*);
int ecriture_fichier(char*);
void del(int,int);
int modi(int,int,int);
void cadr(int ,int);
~matrice();
void aff(int ,int);
void ajout(int ,int ,int);
private:
int nbrLi,nbrCo;
tabs tabH[10],tabV[8];
int **mat;
};
//////////////////////////////////return nbr Li && Co
int matrice::get_nbrLi(void)
{
return nbrLi-1;
}
int matrice::get_nbrCo(void)
{
return nbrCo-1;
}
//////////////////////////////////CLASS NOEUD
class noeud
{
private:
int val,nli,nco;
noeud *sh,*sv;
public:
friend matrice::~matrice();
friend matrice::matrice();
void friend matrice::matcreus(int **,tabs *,tabs *);
int friend matrice::lecture_fichier(char*);
int friend matrice::ecriture_fichier(char*);
void friend matrice::del(int,int);
int friend matrice::modi(int,int,int);
void friend matrice::aff(int ,int);
void friend matrice::ajout(int ,int ,int);
void friend matrice::cadr(int,int);
noeud()
{
sh=NULL;
sv=NULL;
}
};
//////////////////////////////////DELETE
void matrice::del(int i,int j)
{
noeud *bal,*prec;
bal=tabV[i].add;
if(bal->nco==j)
{
tabV[i].add=bal->sh;
delete bal;
}
else
do
{
if(bal->nco==j)
{
prec->sh=bal->sh;
}
prec=bal;
bal=bal->sh;
}while(bal);
bal=tabH[j].add;
if(bal->nli==i)
{
tabH[j].add=bal->sv;
delete bal;
}
else
do
{
if(bal->nli==i)
{
prec->sv=bal->sv;
delete bal;
}
prec=bal;
bal=bal->sv;
}while(bal);
}
//////////////////////////////////MODIFICATION DU VAL
int matrice::modi(int v,int i,int j)
{
noeud *bal;
bal=tabV[i].add;
do
{
if(bal->nco==j)
{
bal->val=v;
return 1;
}
bal=bal->sh;
}while(bal);
return 0;
}
//////////////////////////////////AJOUT De NOEUD
void matrice::ajout(int v,int i,int j)
{
noeud *nd;
nd=new noeud;
nd->val=v;
nd->nli=i;
nd->nco=j;
if(tabV[i].add) //HORIZONTALEMENT
{
noeud* bal;
noeud* prec;
bal=tabV[i].add;
if(bal->nco>j)
{
tabV[i].add=nd;
nd->sh=bal;
}
else
{
do
{
prec=bal;
bal=bal->sh;
}while(bal && bal->nco<j);
prec->sh=nd;
if(bal)
nd->sh=bal;
}
}
else
tabV[i].add=nd;
/*if(tabH[j].add) //VERTICALEMENT
{
noeud* bal;
noeud* prec;
bal=tabH[j].add;
if(bal->nli>i)
{
tabH[j].add=nd;
nd->sv=bal;
}
else
{
do
{
prec=bal;
bal=bal->sv;
}while(bal && bal->nli<i);
prec->sv=nd;
if(bal)
nd->sv=bal;
}
}
else
tabH[j].add=nd;*/
}
//////////////////////////////////AFFICHEUR
void matrice::aff(int l,int c)
{
int a=8,z=8;
gotoxy(a,z);
for(int i=l;i<7+l && i<nbrLi;i++) //Zero
{ for(int j=c;j<7+c && j<nbrCo;j++)
{
gotoxy(a,z);
textcolor(WHITE);
cprintf("0");
a+=8;
}
a=8;
z+=6;
}
noeud *bal;
for(i=l;i<7+l&&i<nbrLi;i++)
{
bal=tabV[i].add;
{
while(bal->nco<c)
bal=bal->sh;
if(bal)
do
{
gotoxy(8+8*(bal->nco-c),8+6*(i-l));
textcolor(5);
if(bal->nco<c+7)
cprintf("%d",bal->val);
bal=bal->sh;
}while(bal && bal->nco<7+c && bal->nco<nbrCo);
}
}
}
/////////////////////////////////////////CONSTRUCTEUR
matrice::matrice()
{
lecture_fichier("fichier.txt");
for(int i=0;i<nbrCo;i++)
{
tabH[i].add=NULL;
}
for(i=0;i<nbrLi;i++)
{
tabV[i].add=NULL;
}
matcreus(mat,tabH,tabV);
}
//////////////////////////////////////////DESTRUCTEUR
matrice::~matrice()
{
for(int i=0;i<nbrLi;i++)
delete mat[i];
delete *mat;
noeud *bal,*prec;
for( i=0;i<nbrLi;i++)
{
if(bal)
{
bal=tabV[i].add;
tabV[i].add=NULL;
bal=bal->sh;
do
{
prec=bal;
bal=bal->sh;
delete prec;
}while(bal);
}
}
}
//////////////////////////////////LECTURE FICHIER
int matrice::lecture_fichier(char* nom_fichier)
{
FILE* f=fopen(nom_fichier,"r");
if (f != NULL)
{
fscanf(f,"%d%d",&nbrCo,&nbrLi);
}
else
return 0;
mat = new int* [nbrCo];
for(int i=0;i<nbrLi;i++)
mat[i]=new int[nbrCo];
for(int j=0;j<nbrLi;j++)
{
for (i=0;i<nbrCo;i++)
{
fscanf(f,"%d",&mat[j][i]);
}
}
return 1;
}
///////////////////////////////////////////ECRITURE FICHIER
int matrice::ecriture_fichier(char* nom_fichier)
{
FILE *f=fopen(nom_fichier,"w");
if (f != NULL)
{
fprintf(f,"%d %d\n",nbrCo,nbrLi);
}
else
return 0;
noeud *nid;
for(int i=0;i<nbrLi;i++)
{
int indi=0;
nid=tabV[i].add;
if(!tabV[i].add)
for(int com=0;com<nbrCo;com++)
{
fprintf(f,"0 ");
indi=nbrCo;
}
else
do
{
for(int com=indi;com<nid->nco && indi<nbrCo;com++,indi++)
{
fprintf(f,"0 ");
}
fprintf(f,"%d ",nid->val);
indi++;
nid=nid->sh ;
}while(nid);
for(;indi<nbrCo;indi++)
{
fprintf(f,"0 ");
}
fprintf(f,"\n");
}
fclose(f);
return 1;
}
//*****************************************MATCRUS
void matrice::matcreus(int **l,tabs *tabH,tabs *tabV)
{
for(int i=0;i<nbrLi;i++)
for(int j=0;j<nbrCo;j++)
{
if(l[i][j])
{
noeud* bal;
noeud* prec,*nd;
nd=new noeud;
nd->val=l[i][j];
nd->nli=i;
nd->nco=j;
if(tabH[j].add!=NULL)
{
bal=tabH[j].add;
do
{
prec=bal;
bal=bal->sv;
}while(bal);
prec->sv=nd;
}
else
tabH[j].add=nd;
if(tabV[i].add!=NULL)
{
bal=tabV[i].add;
do
{
prec=bal;
bal=bal->sh;
}while(bal);
prec->sh=nd;
}
else
tabV[i].add=nd;
}
}
}
/////////////////////////////////////CADRE
void matrice::cadr(int l,int c)
{
char cha=179;
textcolor(WHITE);
gotoxy(66,14);cprintf("0 : Suppr");
gotoxy(66,16);cprintf("int : Modifier");
gotoxy(66,18);cprintf("Esc : Quitter");
gotoxy(66,20);cprintf("Entrer : Save");
int cc=8*c+4,ll=4+6*l;
for(int i=4;i<61&&cc<8*nbrCo+5;i+=8)
{
for(int j=1;j<49 && j<(nbrLi-l)*6+5;j++)
{
gotoxy(i,j);
cprintf("%c",cha);
}
cc+=8;
}
cha=196;
for(i=5;i<49 && ll<6*nbrLi+5;i+=6)
{
for(int j=1;j<62 && j<(nbrCo-c)*8+4;j++)
{
gotoxy(j,i);
cprintf("%c",cha);
}
ll+=6;
}
textcolor(4);
if(c) {
gotoxy(1,1);
cprintf("...");
}
if(l) {
gotoxy(1,1);
cprintf(".");
gotoxy(1,2);
cprintf(".");
gotoxy(1,3);
cprintf(".");
}
for(int h=c,g=8;h<c+7 && h<nbrCo;h++)
{
gotoxy(g,1);
g+=8;
cprintf("%d",h);
}
for(h=l,g=8;h<l+7 && h<nbrLi;h++)
{
gotoxy(1,g);
g+=6;
cprintf("%d",h);
}
}
//////////////////////////////////ISINT&&NOT.NULL
int isint(char c){
if(c>=49 && c<=57)
return 1 ;
else return 0;
}
//////////////////////////////////MAIN
main()
{
char c;
int a=8,z=8;//GOTOXY(a,z);
int i=0,j=0;//INDICE MATRICE
int w=0,x=0;//INDICE FCT AFF
clrscr();
matrice M;
M.cadr(w,x);
M.aff(w,x);
do{
gotoxy(a,z);
c=getch();
fflush(stdin);
if(isint(c))
{
int mo;
mo=M.modi(c-48,i,j);
if(!mo)
M.ajout(c-48,i,j);
M.aff(w,x);
}
if(c==48)
{
M.del(i,j);
M.aff(w,x);
}
if(c==77 && a!=64)
{
if(j==M.get_nbrCo())
printf("\a");
else
{
j++;
a+=8;
gotoxy(a,z);
}
}
if(c==77 && a==64)
{
x+=7;
a=8;
clrscr();
M.cadr(w,x);
M.aff(w,x);
}
if(c==75 && a!=0)
{
if(j==0)
printf("\a");
else
{
j--;
a-=8;
gotoxy(a,z);
}
}
if(c==75 && a==0)
{
x-=7;
a=56;
clrscr();
M.cadr(w,x);
M.aff(w,x);
}
if(c==72 && z!=2)
{
if(i==0)
printf("\a");
else
{
i--;
z-=6;
gotoxy(a,z);
}
}
if(c==72 && z==2)
{
w-=6;
z=38;
clrscr();
M.cadr(w,x);
M.aff(w,x);
}
if(c==80 && z!=50)
{
if(i==M.get_nbrLi())
printf("\a");
else
{
i++;
z+=6;
gotoxy(a,z);
}
}
if(c==80 && z==50)
{
w+=6;
z=14;
clrscr();
M.cadr(w,x);
M.aff(w,x);
}
if(c==13)
{
M.ecriture_fichier("fichier.txt");
}
}while(c!=27 && c!=13);
return 0;
}

#include<conio.h>
#include<stdio.h>
#include<iostream.h>
class noeud;
//////////////////////////////////STRUCT TABLEAU
struct tabs
{
noeud *add;
};
typedef struct tabs tabs;
//////////////////////////////////CLASS MATRICE
class matrice
{
public:
matrice();
int get_nbrLi(void);
int get_nbrCo(void);
void matcreus(int **,tabs *,tabs *);
int lecture_fichier(char*);
int ecriture_fichier(char*);
void del(int,int);
int modi(int,int,int);
void cadr(int ,int);
~matrice();
void aff(int ,int);
void ajout(int ,int ,int);
private:
int nbrLi,nbrCo;
tabs tabH[10],tabV[8];
int **mat;
};
//////////////////////////////////return nbr Li && Co
int matrice::get_nbrLi(void)
{
return nbrLi-1;
}
int matrice::get_nbrCo(void)
{
return nbrCo-1;
}
//////////////////////////////////CLASS NOEUD
class noeud
{
private:
int val,nli,nco;
noeud *sh,*sv;
public:
friend matrice::~matrice();
friend matrice::matrice();
void friend matrice::matcreus(int **,tabs *,tabs *);
int  friend matrice::lecture_fichier(char*);
int  friend matrice::ecriture_fichier(char*);
void friend matrice::del(int,int);
int  friend matrice::modi(int,int,int);
void friend matrice::aff(int ,int);
void friend matrice::ajout(int ,int ,int);
void friend matrice::cadr(int,int);
noeud()
{
sh=NULL;
sv=NULL;
}
};
//////////////////////////////////DELETE
void matrice::del(int i,int j)
{
noeud *bal,*prec;
bal=tabV[i].add;
if(bal->nco==j)
	{
	tabV[i].add=bal->sh;
	delete bal;
	}
else
	do
	{
	if(bal->nco==j)
		{
		prec->sh=bal->sh;
		}
	prec=bal;
	bal=bal->sh;
	}while(bal);
bal=tabH[j].add;
if(bal->nli==i)
	{
	tabH[j].add=bal->sv;
	delete bal;
	}
else
	do
	{
	if(bal->nli==i)
		{
		prec->sv=bal->sv;
		delete bal;
		}
	prec=bal;
	bal=bal->sv;
	}while(bal);
}
//////////////////////////////////MODIFICATION DU VAL
int matrice::modi(int v,int i,int j)
{
noeud *bal;
bal=tabV[i].add;
do
{

if(bal->nco==j)
	{
	bal->val=v;
	return 1;
	}
bal=bal->sh;
}while(bal);
return 0;
}
//////////////////////////////////AJOUT De NOEUD
void matrice::ajout(int v,int i,int j)
{
noeud *nd;
nd=new noeud;
nd->val=v;
nd->nli=i;
nd->nco=j;
if(tabV[i].add)  //HORIZONTALEMENT
	{
	noeud* bal;
	noeud* prec;
	bal=tabV[i].add;
	if(bal->nco>j)
		{
		tabV[i].add=nd;
		nd->sh=bal;
		}
	else
	{
		do
		{
		prec=bal;
		bal=bal->sh;
		}while(bal && bal->nco<j);
		prec->sh=nd;
		if(bal)
		nd->sh=bal;
	}
	}
else
	tabV[i].add=nd;
/*if(tabH[j].add)  //VERTICALEMENT
	{
	noeud* bal;
	noeud* prec;
	bal=tabH[j].add;
	if(bal->nli>i)
		{
		tabH[j].add=nd;
		nd->sv=bal;
		}
	else
	{
		do
		{
		prec=bal;
		bal=bal->sv;
		}while(bal && bal->nli<i);
		prec->sv=nd;
		if(bal)
		nd->sv=bal;
	}
	}
else
	tabH[j].add=nd;*/
}
//////////////////////////////////AFFICHEUR
void matrice::aff(int l,int c)
{
int a=8,z=8;
gotoxy(a,z);
for(int i=l;i<7+l && i<nbrLi;i++)       //Zero
{	for(int j=c;j<7+c && j<nbrCo;j++)
	{
		gotoxy(a,z);
		textcolor(WHITE);
		cprintf("0");
		a+=8;
		}
		a=8;
		z+=6;
	}
	noeud *bal;
	for(i=l;i<7+l&&i<nbrLi;i++)
	{
		bal=tabV[i].add;
		{
		while(bal->nco<c)
			bal=bal->sh;
		if(bal)
		do
		{
		gotoxy(8+8*(bal->nco-c),8+6*(i-l));
		textcolor(5);
		if(bal->nco<c+7)
			cprintf("%d",bal->val);
		bal=bal->sh;
		}while(bal && bal->nco<7+c && bal->nco<nbrCo);
		}
	}
}
/////////////////////////////////////////CONSTRUCTEUR
matrice::matrice()
{
lecture_fichier("fichier.txt");
for(int i=0;i<nbrCo;i++)
	{
	tabH[i].add=NULL;
	}
	for(i=0;i<nbrLi;i++)
	{
	tabV[i].add=NULL;
	}
matcreus(mat,tabH,tabV);
}
//////////////////////////////////////////DESTRUCTEUR
matrice::~matrice()
{
for(int i=0;i<nbrLi;i++)
delete mat[i];
delete *mat;
noeud *bal,*prec;
for( i=0;i<nbrLi;i++)
	{
	if(bal)
		{

		bal=tabV[i].add;
		tabV[i].add=NULL;
		bal=bal->sh;
		do
		{
		prec=bal;
		bal=bal->sh;
		delete prec;
		}while(bal);
		}
	}
}
//////////////////////////////////LECTURE FICHIER
int matrice::lecture_fichier(char* nom_fichier)
    {
    FILE* f=fopen(nom_fichier,"r");
    if (f != NULL)
    {
       fscanf(f,"%d%d",&nbrCo,&nbrLi);
    }
   else
	 return 0;
   mat = new int* [nbrCo];
   for(int i=0;i<nbrLi;i++)
   mat[i]=new int[nbrCo];

   for(int j=0;j<nbrLi;j++)
   {
	  for (i=0;i<nbrCo;i++)
	  {
		fscanf(f,"%d",&mat[j][i]);
	  }
   }
   return 1;
   }
///////////////////////////////////////////ECRITURE FICHIER
int matrice::ecriture_fichier(char* nom_fichier)
    {
    FILE *f=fopen(nom_fichier,"w");
    if (f != NULL)
    {
       fprintf(f,"%d %d\n",nbrCo,nbrLi);
    }
   else
	 return 0;
noeud *nid;
for(int i=0;i<nbrLi;i++)
{
int indi=0;
nid=tabV[i].add;
if(!tabV[i].add)
	for(int com=0;com<nbrCo;com++)
	{
	fprintf(f,"0 ");
	indi=nbrCo;
	}
else
	do
	 {
	 for(int com=indi;com<nid->nco && indi<nbrCo;com++,indi++)
		{
		 fprintf(f,"0 ");
		}
	 fprintf(f,"%d ",nid->val);
	 indi++;
	 nid=nid->sh ;
	 }while(nid);
for(;indi<nbrCo;indi++)
{
	fprintf(f,"0 ");
}
fprintf(f,"\n");
}


    fclose(f);
    return 1;
   }
//*****************************************MATCRUS
void matrice::matcreus(int **l,tabs *tabH,tabs *tabV)
{
for(int i=0;i<nbrLi;i++)
	for(int j=0;j<nbrCo;j++)
		{
		if(l[i][j])
			{
			noeud* bal;
			noeud* prec,*nd;
			nd=new noeud;
			nd->val=l[i][j];
			nd->nli=i;
			nd->nco=j;
			if(tabH[j].add!=NULL)
				{
				bal=tabH[j].add;
				do
				{
				prec=bal;
				bal=bal->sv;
				}while(bal);
				prec->sv=nd;
				}
			else
				tabH[j].add=nd;

			if(tabV[i].add!=NULL)
				{
				bal=tabV[i].add;
				do
				{
				prec=bal;
				bal=bal->sh;
				}while(bal);
				prec->sh=nd;
				}
			else
				tabV[i].add=nd;

			}
		}
}
/////////////////////////////////////CADRE
void matrice::cadr(int l,int c)
{
char cha=179;
textcolor(WHITE);
gotoxy(66,14);cprintf("0 : Suppr");
gotoxy(66,16);cprintf("int : Modifier");
gotoxy(66,18);cprintf("Esc : Quitter");
gotoxy(66,20);cprintf("Entrer : Save");
int cc=8*c+4,ll=4+6*l;
for(int i=4;i<61&&cc<8*nbrCo+5;i+=8)
	{
	for(int j=1;j<49 && j<(nbrLi-l)*6+5;j++)
		{
		gotoxy(i,j);
		cprintf("%c",cha);
		}
		cc+=8;
	}
cha=196;

for(i=5;i<49 && ll<6*nbrLi+5;i+=6)
	{
		for(int j=1;j<62 && j<(nbrCo-c)*8+4;j++)
		{
		gotoxy(j,i);
		cprintf("%c",cha);
		}
		ll+=6;
	}
textcolor(4);
if(c)   {
	gotoxy(1,1);
	cprintf("...");
	}
if(l)   {
	gotoxy(1,1);
	cprintf(".");
	gotoxy(1,2);
	cprintf(".");
	gotoxy(1,3);
	cprintf(".");
	}
for(int h=c,g=8;h<c+7 && h<nbrCo;h++)
	{
	gotoxy(g,1);
	g+=8;
	cprintf("%d",h);
	}
for(h=l,g=8;h<l+7 && h<nbrLi;h++)
	{
	gotoxy(1,g);
	g+=6;
	cprintf("%d",h);
	}

}
//////////////////////////////////ISINT&&NOT.NULL
int isint(char c){
if(c>=49 && c<=57)
	return 1 ;
else 	return 0;
}
//////////////////////////////////MAIN
main()
{
char c;
int a=8,z=8;//GOTOXY(a,z);
int i=0,j=0;//INDICE MATRICE
int w=0,x=0;//INDICE FCT AFF
clrscr();
matrice M;
M.cadr(w,x);
M.aff(w,x);
do{
gotoxy(a,z);
c=getch();
fflush(stdin);
if(isint(c))
	{
	int mo;
	mo=M.modi(c-48,i,j);
	if(!mo)
		M.ajout(c-48,i,j);
	M.aff(w,x);
	}
if(c==48)
	{
	M.del(i,j);
	M.aff(w,x);
	}
if(c==77 && a!=64)
	{
	if(j==M.get_nbrCo())
		printf("\a");
	else
		{
		j++;
		a+=8;
		gotoxy(a,z);
		}
	}
if(c==77 && a==64)
	{
	x+=7;
	a=8;
	clrscr();
	M.cadr(w,x);
	M.aff(w,x);
	}
if(c==75 && a!=0)
	{
	if(j==0)
		printf("\a");
	else
		{
		j--;
		a-=8;
		gotoxy(a,z);
		}
	}
if(c==75 && a==0)
	{
	x-=7;
	a=56;
	clrscr();
	M.cadr(w,x);
	M.aff(w,x);
	}
if(c==72 && z!=2)
	{
	if(i==0)
		printf("\a");
	else
		{
		i--;
		z-=6;
		gotoxy(a,z);
		}
	}
if(c==72 && z==2)
	{
	w-=6;
	z=38;
	clrscr();
	M.cadr(w,x);
	M.aff(w,x);
	}
if(c==80 && z!=50)
	{
	if(i==M.get_nbrLi())
		printf("\a");
	else
		{
		i++;
		z+=6;
		gotoxy(a,z);
		}
	}
if(c==80 && z==50)
	{
	w+=6;
	z=14;
	clrscr();
	M.cadr(w,x);
	M.aff(w,x);
	}
if(c==13)
	{
	M.ecriture_fichier("fichier.txt");
	}
}while(c!=27 && c!=13);
return 0;
}

Conclusion

n'oublier pas de donner une note à ce code source . Aaaaaaaaaaaaaara liyya

Fichier Zip

Pour les "Membres Club", vous pouvez télécharger directement un fichier contenu dans le zip sans télécharger le zip en entier !

fichier.txt 182 octets
MatriceCreuse.CPP 8 172 octets

Télécharger le zip

Historique

13 mai 2008 23:11:00 :: j'ai oublié la capture
16 mai 2008 13:29:43 :: correction

Sources de la même categorie

Toutes les sources de la catégorie Application

Sources en rapport avec celle ci

Commentaires

Commentaire de vecchio56 le 13/05/2008 22:11:35 administrateur CS

Une matrice creuse est une matrice qui contient "beaucoup" de zéros.
C'est ton implémentation qui ne stocke que les valeurs non-nulles (une implémentation classique de matrice pourrait très bien être utilisée pour représenter une matrice creuse)
Commentaire de Jctickle le 14/05/2008 13:44:28

Bonjour,

je pense que tu as une erreur ligne 48

friend matrice::~matrice()

Tu as oublié le ; à la fin
Donc => friend matrice::~matrice();

Ceci dis, pour l'instant, je test, parce que, bon, je suis pas un génie en C/C++ mais bon, je suis curieux :-) donc, Code::Blocks me dit qu'il y a des erreurs .. ceci dis, ben, je ne sais pas les corrigées, puis qui sais peut être que c'est mon code::blocks qui déconne.

Bien à toi.

Jctickle
Commentaire de Matt67 le 15/05/2008 02:33:43

Bonjour,

#include<conio.h>
#include<stdio.h>
#include<iostream.h>

Quand je vois ça, je ne vais pas plus loin.
On fait quoi ? du C ou du C++.
Du c, donc pas de iostream.h.
Du C++ donc #include<iostream> et/ou #include<cstdio>.
Et #include<conio.h> kesako ??? mon bouquin sur le c n'en parle pas (k&r).

Sinon, bonne journée.

Matt
Commentaire de Renfield le 15/05/2008 07:39:26 administrateur CS

conio...

pour manipuler la console (couleur, deplacer le curseur, etc)
Commentaire de belhauss le 16/05/2008 13:22:48

merçi Jctickle pour la coorection :P;
Hey Matt67 j'ai utilisé les header conio et stdio just pour gérer l'affichage, mais le code c'est du pure C++ (xD);
Commentaire de Matt67 le 17/05/2008 09:40:02

Bonjour,

RENFIELD : manipuler la console !!! Wouah, pour faire des beautiful programme en console. Y a des trucs maintenant qui s'appelle des fenetres...

BELHAUSS :
1) Un code source de 531 lignes, aurait peut ?tre m?rit? un zip (enfin, j'dis ?a, j'dis rien).
2) En "pure C++", les "headers" n'ont pas le .h ex : #include <iostream> et si tu veux utiliser les headers du C c'est #include <cstdio>. ceci afin de faire du "pure C++".
3) Copier/coller ton code, compile pas, en parti ? cause du 'conio.h'. Remarque s'il avait compil?, qu'est ce que j'en aurai fait. Moi et les matrices creuses, on est fach? depuis tout petit...
4) Une p'tite question, c'est quoi du "pure C++" ???

Bonne Journ?e,

Matt
Commentaire de Matt67 le 17/05/2008 09:43:03

Tiens, quel est mon codage de caracteres ???

Matt...
Commentaire de belhauss le 17/05/2008 10:13:39

ahhhh t aggressif toi ahh !!!!take it easy.
1)pour le zip du code bah comme bah la gestion de curseur et de l'?cran c'est elle qui rend ce code m?ga g?ant.
2)pour le "pure C++"je t'invite a le revoire dans mon commmentaire pr?cedent et si t'as bien compris ce code (xD)je dit bien si (xD) bon c'est un ?motion.et pour les headers un fichier *.h veut dire *.header donc se sont des headers (xD).
3)mon code marche parfaitement(xD) vous utilisez quoi comme compilateur (sa marche qu'avec Turbo C++ oui oui le fond bleu avec caracht?re Jaune jaune :)).et en plus t'as besoin du fichier nom? fichier dans le zip ,la matrice est sauvegard? dedans.
4)le pure C++ ce ?motion (xD)annule tous ce qui est dit avant donc j'?t? entrain de loler .

Paix,Salam,Peace..
Commentaire de Matt67 le 17/05/2008 11:03:53

re,

D?sol?, mais j'ai pas tout compris ce que tu avais ?crit. Je vais quand m?me r?pondre.
Pour le zip, chacun voit midi ? ?a porte.
Pour le code, j'ai pas regard?.
Pour le pure C++, j'ai pas encore compris.
Pour les "headers", je maintiens ce que j'ai dit, ? savoir : #include <iostream> et si tu veux utiliser les fichiers ent?tes C : #include <cstdio>

Apparemment, d'apr?s ce que j'ai lu, ?a ne marche (je dirai ?a ne compile) qu'avec le compilateur de borland livr? avec l'IDE Turbo C++. Donc le pure C++, c'est le C++ de Borland ?

Enfin, je n'ai rien vu d'agressif dans mes propos mais je discute seulement,

Bonne journ?e,

Matt
Commentaire de belhauss le 17/05/2008 15:05:29

Re:
hahaha le pure C++,bah ?a ete just une metaphore oublions sa .
oui sa marche tr?s bien avec le turbo C++, si tu le veux passe moi ton email dans msg priv? (meme pas 6Mb).

Paix,Peace,Salam ...
Commentaire de vecchio56 le 17/05/2008 16:35:32 administrateur CS

Turbo C++ c'est un compilateur pr?historique, personne ne l'utilise plus (ou plut?t personne ne devrait plus l'utiliser).
Le "pure C++" t'a dit ?a pour plaisanter, mais il existe quand m?me ce qu'on appelle une norme, et quand on la respecte, le code qu'on ?crit va pouvoir ?tre compil? par tout compilateur qui respecte la norme (c'est a peu pr?s le cas de tous les compilateurs r?cents).
Puisque tu proposes aux gens d'utiliser Turbo C++, je te propose d'essayer a ton tour Visual C++ Express qui est gratuit et qui te permettra d'?crire du code de meilleure qualit?.
Commentaire de Matt67 le 17/05/2008 17:28:05

Vecchio56 : Avec le bloc note, je pense que l'on peut ecrire du code de bonne qualit? aussi...
Belhauss : Non merci, j'ai ce qui faut ? la maison.

Bonne Journ?e,

Matt...
Commentaire de vecchio56 le 17/05/2008 17:35:53 administrateur CS

Oui je sais, on peut m?me l'?crire sur un bout de papier si on veut
Ce que je voulais dire c'est que comme le compilateur respecte les normes, tu devra ?crire du code correct (par exemple tu peux pas ?crire #include <iostream.h>)
Commentaire de belhauss le 17/05/2008 18:17:00

mmmmm donc moi jai dit "le pure c++" just par hasard :P srry.
vecchio56 :je propose pas aux gens le Turbo aahhhh la je suis mal compris j'ai just remarque ke matt67 est interesse au code et il a des erreures due a son compilateur en fet due a mon code pr?historique lol.
ahhh encors une fois mal juge :( je programme avec des fenetres j'utilise le C#,vb.NET!!!! j'ai just vouler partager avec vous ce code source .

salam,paix,Peace

Ajouter un commentaire

Discussions en rapport avec ce code source

Créer une matrix a partir d'un BMP ou DIB URGENT par pirate75000

effet matrix par morgandetoi06

Probleme de tableau entre C et C++ par fred23

strcutres de donnees: graph par djkill55

C++ de merde...enfin je veux dire... par brindillee

Templates persos par nicolas66

logiciel de IRC à la sauce matrix! par black_lotus6

Pb de destructeur par Stubbornman

Manipulation de matrices en C. par T TeKa K

Problème de cast avec template par xkamen