Ejemplo n.º 1
0
Archivo: main.c Proyecto: bechea/tp_c
int main()
{
	float tab_ini[10] = {0, 5.5, 6, 8, 9.25, 6.5, 5.75, 3, 6.25, 6};
	int taille = 10;
	float *tab_fin = NULL;
	int inter;
	float moy;
	int i;
	int j = 0;

	moy = tab_moyen(tab_ini, taille);
	inter = intervalle(tab_ini, moy, taille);

	tab_fin = malloc(inter * sizeof(float));

	for(i = 0 ; i < taille ; i++)
	{
		if((tab_ini[i] >= moy - 2) && (tab_ini[i] <= moy + 2))
		{
			tab_fin[j] = tab_ini[i];
			printf("%f\n",tab_fin[j]);
			j++;
		}
	}
	printf("Moyenne du tableau intervalle : %f\n",tab_moyen(tab_fin,inter));

	free(tab_fin);
	return 1;
}
Ejemplo n.º 2
0
// ----------------------------------------------------------------------------
int main( int nombreDArguments, char *arguments[ ] )
// ----------------------------------------------------------------------------
{
	char *nomDuFichierDeCorrection = "correction.txt";
	if ( nombreDArguments == 2 ) {
		nomDuFichierDeCorrection = arguments[ 1 ];
	}
	ofstream correction = ofstream( nomDuFichierDeCorrection, ios::out );
	if ( correction == 0 ) {
		cerr << "Echec de l'ouverture de \"" << nomDuFichierDeCorrection
			<< "\"" << endl;
		return 1;
	}

	char message[ 1024 ];
	double valeur;
	bool continuer = true;
	double noteMax = 0.0;
	double note = 0.0;
	unsigned int numeroDeTest = 0;

 	EntierBorne unite;


	/*
	* test des limites d'un EntierBorne implicite.
	*/
	numeroDeTest++;
	valeur = 10.0;
	noteMax += valeur;
	note -= valeur;
	if ( continuer ) {
		note += valeur;
		if ( unite.fournirMinimum( ) != 0 ) {
			note -= valeur;
			continuer = false;
			char *pt = message;
			sprintf( pt,
				"(%u) fournirMinimum( ) d'un EntierBorne implicite devrait\n",
				numeroDeTest );
			sprintf( pt += strlen( pt ),
				"etre 0.\n" );
			rapporter( correction, message );
		}
	}
	
	numeroDeTest++;
	valeur = 10.0;
	noteMax += valeur;
	note -= valeur;
	if ( continuer ) {
		note += valeur;
		if ( unite.fournirMaximum( ) != 1 ) {
			note -= valeur;
			continuer = false;
			char *pt = message;
			sprintf( pt,
				"(%u) fournirMaximum( ) d'un EntierBorne implicite devrait\n",
				numeroDeTest );
			sprintf( pt += strlen( pt ),
				"etre 1.\n" );
			rapporter( correction, message );
		}
	}

	numeroDeTest++;
	valeur = 10.0;
	noteMax += valeur;
	note -= valeur;
	if ( continuer ) {
		note += valeur;
		if ( unite.fournirValeur( ) != 0 ) {
			note -= valeur;
			continuer = false;
			char *pt = message;
			sprintf( pt,
				"(%u) fournirMaximum( ) d'un EntierBorne implicite devrait\n",
				numeroDeTest );
			sprintf( pt += strlen( pt ),
				"etre 1.\n" );
			rapporter( correction, message );
		}
	}

	int minimum = 0;
	int maximum = 10;
 	EntierBorne indice( minimum, maximum );

	numeroDeTest++;
	valeur = 10.0;
	noteMax += valeur;
	note -= valeur;
	if ( continuer ) {
		note += valeur;
		if ( indice.fournirMinimum( ) != minimum ) {
			note -= valeur;
			continuer = false;
			char *pt = message;
			sprintf( pt,
				"(%u) fournirMinimum( ) d'un EntierBorne implicite devrait\n",
				numeroDeTest );
			sprintf( pt += strlen( pt ),
				"etre 0.\n" );
			rapporter( correction, message );
		}
	}
	
	numeroDeTest++;
	valeur = 10.0;
	noteMax += valeur;
	note -= valeur;
	if ( continuer ) {
		note += valeur;
		if ( indice.fournirMaximum( ) != maximum ) {
			note -= valeur;
			continuer = false;
			char *pt = message;
			sprintf( pt,
				"(%u) fournirMaximum( ) d'un EntierBorne implicite devrait\n",
				numeroDeTest );
			sprintf( pt += strlen( pt ),
				"etre 1.\n" );
			rapporter( correction, message );
		}
	}
	
	numeroDeTest++;
	valeur = 10.0;
	noteMax += valeur;
	note -= valeur;
	if ( continuer ) {
		note += valeur;
		if ( indice.fournirValeur( ) != minimum ) {
			note -= valeur;
			continuer = false;
			char *pt = message;
			sprintf( pt,
				"(%u) fournirMaximum( ) d'un EntierBorne implicite devrait\n",
				numeroDeTest );
			sprintf( pt += strlen( pt ),
				"etre 1.\n" );
			rapporter( correction, message );
		}
	}

	indice.fixerAuMaximum( );
	numeroDeTest++;
	valeur = 10.0;
	noteMax += valeur;
	note -= valeur;
	if ( continuer ) {
		note += valeur;
		if ( indice.fournirValeur( ) != maximum ) {
			note -= valeur;
			continuer = false;
			char *pt = message;
			sprintf( pt,
				"(%u) fournirMaximum( ) d'un EntierBorne implicite devrait\n",
				numeroDeTest );
			sprintf( pt += strlen( pt ),
				"etre 1.\n" );
			rapporter( correction, message );
		}
	}

	indice.fixerAuMinimum( );
	numeroDeTest++;
	valeur = 10.0;
	noteMax += valeur;
	note -= valeur;
	if ( continuer ) {
		note += valeur;
		if ( indice.fournirValeur( ) != minimum ) {
			note -= valeur;
			continuer = false;
			char *pt = message;
			sprintf( pt,
				"(%u) fournirMaximum( ) d'un EntierBorne implicite devrait\n",
				numeroDeTest );
			sprintf( pt += strlen( pt ),
				"etre 1.\n" );
			rapporter( correction, message );
		}
	}

	numeroDeTest++;
	valeur = 10.0;
	noteMax += valeur;
	note -= valeur;
	if ( continuer ) {
		note += valeur;
		bool exceptionCapturee = false;
		try {
			indice.modifierValeur( maximum + 1 );
		}
		catch( EntierBorne::HorsBornes ) {
			exceptionCapturee = true;
		}
		if ( !exceptionCapturee ) {
			note -= valeur;
			continuer = false;
			char *pt = message;
			sprintf( pt,
				"(%u) exception HorsBornes non declenchee dans\n",
				numeroDeTest );
			sprintf( pt += strlen( pt ),
				"modifierValeur().\n" );
			rapporter( correction, message );
		}
	}

	numeroDeTest++;
	valeur = 10.0;
	noteMax += valeur;
	note -= valeur;
	if ( continuer ) {
		note += valeur;
		bool exceptionCapturee = false;
		try {
			indice.modifierValeur( minimum - 1 );
		}
		catch( EntierBorne::HorsBornes ) {
			exceptionCapturee = true;
		}
		if ( !exceptionCapturee ) {
			note -= valeur;
			continuer = false;
			char *pt = message;
			sprintf( pt,
				"(%u) exception HorsBornes non declenchee dans\n",
				numeroDeTest );
			sprintf( pt += strlen( pt ),
				"modifierValeur().\n" );
			rapporter( correction, message );
		}
	}

	numeroDeTest++;
	valeur = 10.0;
	noteMax += valeur;
	note -= valeur;
	if ( continuer ) {
		note += valeur;
		bool exceptionCapturee = false;
		try {
			indice.modifierValeur( maximum );
		}
		catch( EntierBorne::HorsBornes ) {
			exceptionCapturee = true;
		}
		if ( exceptionCapturee ) {
			note -= valeur;
			continuer = false;
			char *pt = message;
			sprintf( pt,
				"(%u) exception HorsBornes declenchee pour valeur = maximum dans\n",
				numeroDeTest );
			sprintf( pt += strlen( pt ),
				"modifierValeur().\n" );
			rapporter( correction, message );
		}
	}

	numeroDeTest++;
	valeur = 10.0;
	noteMax += valeur;
	note -= valeur;
	if ( continuer ) {
		note += valeur;
		bool exceptionCapturee = false;
		try {
			indice.modifierValeur( minimum );
		}
		catch( EntierBorne::HorsBornes ) {
			exceptionCapturee = true;
		}
		if ( exceptionCapturee ) {
			note -= valeur;
			continuer = false;
			char *pt = message;
			sprintf( pt,
				"(%u) exception HorsBornes declenchee pour valeur = minimum dans\n",
				numeroDeTest );
			sprintf( pt += strlen( pt ),
				"modifierValeur().\n" );
			rapporter( correction, message );
		}
	}

	IntervalleEntier intervalle( minimum, maximum );
 	EntierBorne repere( intervalle );

	numeroDeTest++;
	valeur = 10.0;
	noteMax += valeur;
	note -= valeur;
	if ( continuer ) {
		note += valeur;
		if ( repere.fournirMinimum( ) != minimum ) {
			note -= valeur;
			continuer = false;
			char *pt = message;
			sprintf( pt,
				"(%u) fournirMinimum( ) d'un EntierBorne construit sur un\n",
				numeroDeTest );
			sprintf( pt += strlen( pt ),
				"IntervalleEntier [0..10] devrait renvoyer 0.\n" );
			rapporter( correction, message );
		}
	}

	numeroDeTest++;
	valeur = 10.0;
	noteMax += valeur;
	note -= valeur;
	if ( continuer ) {
		note += valeur;
		if ( repere.fournirMaximum( ) != maximum ) {
			note -= valeur;
			continuer = false;
			char *pt = message;
			sprintf( pt,
				"(%u) fournirMinimum( ) d'un EntierBorne construit sur un\n",
				numeroDeTest );
			sprintf( pt += strlen( pt ),
				"IntervalleEntier [0..10] devrait renvoyer 10.\n" );
			rapporter( correction, message );
		}
	}

	numeroDeTest++;
	valeur = 10.0;
	noteMax += valeur;
	note -= valeur;
	if ( continuer ) {
		note += valeur;
		bool exceptionCapturee = false;
		try {
			repere.modifierValeur(( maximum + minimum )/2 );
		}
		catch( EntierBorne::HorsBornes ) {
			exceptionCapturee = true;
		}
		if ( exceptionCapturee ) {
			note -= valeur;
			continuer = false;
			char *pt = message;
			sprintf( pt,
				"(%u) fixer un EntierBorne au milieur de son IntervalleEntier\n",
				numeroDeTest );
			sprintf( pt += strlen( pt ),
				"ne devrait pas declencher d'exception.\n" );
			rapporter( correction, message );
		}
	}

	numeroDeTest++;
	valeur = 10.0;
	noteMax += valeur;
	note -= valeur;
	if ( continuer ) {
		note += valeur;
		bool exceptionCapturee = false;
		try {
			repere.modifierValeur( maximum + 1 );
		}
		catch( EntierBorne::HorsBornes ) {
			exceptionCapturee = true;
		}
		if ( !exceptionCapturee ) {
			note -= valeur;
			continuer = false;
			char *pt = message;
			sprintf( pt,
				"(%u) fixer un EntierBorne au dessus de son maximum\n",
				numeroDeTest );
			sprintf( pt += strlen( pt ),
				"devrait declencher l'exception HorsBornes.\n" );
			rapporter( correction, message );
		}
	}

	numeroDeTest++;
	valeur = 10.0;
	noteMax += valeur;
	note -= valeur;
	if ( continuer ) {
		note += valeur;
		bool exceptionCapturee = false;
		try {
			repere.modifierValeur( minimum - 1 );
		}
		catch( EntierBorne::HorsBornes ) {
			exceptionCapturee = true;
		}
		if ( !exceptionCapturee ) {
			note -= valeur;
			continuer = false;
			char *pt = message;
			sprintf( pt,
				"(%u) fixer un EntierBorne au dessous de son minimum\n",
				numeroDeTest );
			sprintf( pt += strlen( pt ),
				"devrait declencher l'exception HorsBornes.\n" );
			rapporter( correction, message );
		}
	}

	numeroDeTest++;
	valeur = 10.0;
	noteMax += valeur;
	note -= valeur;
	if ( continuer ) {
		note += valeur;
		bool exceptionCapturee = false;
		try {
			repere.modifierValeur( minimum );
		}
		catch( EntierBorne::HorsBornes ) {
			exceptionCapturee = true;
		}
		if ( exceptionCapturee ) {
			note -= valeur;
			continuer = false;
			char *pt = message;
			sprintf( pt,
				"(%u) fixer un EntierBorne a son minimum ne devrait pas\n",
				numeroDeTest );
			sprintf( pt += strlen( pt ),
				"declencher d'exception.\n" );
			rapporter( correction, message );
		}
	}

	numeroDeTest++;
	valeur = 10.0;
	noteMax += valeur;
	note -= valeur;
	if ( continuer ) {
		note += valeur;
		bool exceptionCapturee = false;
		try {
			repere.modifierValeur( maximum );
		}
		catch( EntierBorne::HorsBornes ) {
			exceptionCapturee = true;
		}
		if ( exceptionCapturee ) {
			note -= valeur;
			continuer = false;
			char *pt = message;
			sprintf( pt,
				"(%u) fixer un EntierBorne a son maximum ne devrait pas\n",
				numeroDeTest );
			sprintf( pt += strlen( pt ),
				"declencher d'exception.\n" );
			rapporter( correction, message );
		}
	}

	numeroDeTest++;
	valeur = 10.0;
	noteMax += valeur;
	note -= valeur;
	if ( continuer ) {
		note += valeur;
		bool exceptionCapturee = false;
		try {
			repere++;
		}
		catch( EntierBorne::HorsBornes ) {
			exceptionCapturee = true;
		}
		if ( !exceptionCapturee ) {
			note -= valeur;
			continuer = false;
			char *pt = message;
			sprintf( pt,
				"(%u) decrementer un EntierBorne en dessous de son minimum devrait\n",
				numeroDeTest );
			sprintf( pt += strlen( pt ),
				"declencher l'exception HorsBornes.\n" );
			rapporter( correction, message );
		}
	}

	int notes[ 10 ];
	EntierBorne index( 0, 10 );
	notes[ 3 ] = 3;

	numeroDeTest++;
	valeur = 10.0;
	noteMax += valeur;
	note -= valeur;
	if ( continuer ) {
		note += valeur;
		if ( notes[ 3 ] != 3 ) {
			note -= valeur;
			continuer = false;
			char *pt = message;
			sprintf( pt,
				"(%u) Un EntierBorne utiliser en indice de tableau devrait\n",
				numeroDeTest );
			sprintf( pt += strlen( pt ),
				"acceder a la cellule correspondant a sa valeur.\n" );
			rapporter( correction, message );
		}
	}

	/* ----------------------------- service --------------------------------- */
	note += noteMax;
	note = note/noteMax;
	sprintf( message, "note obtenue: %6.2lf.\n", note );
	rapporter( correction, message );
	return 0;
}