Calcul de resistance equivalante de plusieurs resistances en serie ou parallele

Soyez le premier à donner votre avis sur cette source.

Snippet vu 11 955 fois - Téléchargée 19 fois

Contenu du snippet

Alors voila c'est mon premier code, un exercice pour voir comment faire des allocations dynamiques surtout.

merci de me dire ce que vous en pensez

Source / Exemple :


#include <stdio.h>
#include <stdlib.h>
#include <math.h> // pour recuperer la partie decimale
#include <string.h> // pour convertir un double en char

void main ()
{

	while (1) // boucle infinie pour que le programme ne se quitte pas tout seul
	{

	// on declare les varriables

	char ctype = 0 ;			// Caractere taper par l'utilisateur pour l'appel des fonctions
	char caff_resultat [20] ;	// Chaine contenant le resultat dont les zeros inutiles de la partie decimale ont été tronqués

	int inbresistor = 0 ;		// Nombre de resistances
	int ilong ;					// longueur de la chaine "caff_resultat" pour pouvoir tronquer les zeros superflux

	double Req = 0 ;			// Resistance equivalante
	double dAd = 0 ;			// inverse de la resistance euivalante
	double dec = 0 ;			// parite decimale de la resistance equivalante
	double ent = 0 ;			// partie entiere de la resistance equivalante

	// on declare les tableau pour allocation dynamique

	double *resistor ; // tableau contenant les valeur des resistances
	double *G ;		   // tableau contenant les inverses des resistances

		// On boucle pour que l'utilisateur ne puisse appuyer que sur les touches predifinies

		while ( ctype != '1' )	// on sort de la boucle si l'utilisateur appui sur "1"
		{	
			if ( ctype == '2' )
			{ break ; }			// on sort de la boucle si l'utilisateur appui sur "2"
			if ( ctype == 'Q' )
			{ exit (-1) ; }		// on quitte le programme si l'utilisateur appui sur "Q"

			system ("cls") ;

			printf ( "1 : Resistances en serie.\n\n2 : resistances en parallele. \n\nQ : quiter le programme. " );

			scanf( "%s", &ctype ) ;
		}
		
		if ( ctype == '1' )

		{
			system ("cls") ;
			printf ( "vous avez selectionner des resistances en serie.\n\n" ) ;
			printf ( "combien de resistances avez vous?\n\n " ) ;

			scanf ( "%d", &inbresistor ) ;
		}

		else if ( ctype == '2' )

		{
			system ("cls") ;
			printf ( "vous avez selectionner des resistances en parallele.\n\n" ) ;
			printf ( "combien de resistances avez vous?\n\n " ) ;

			scanf ( "%d", &inbresistor ) ;
		}

		if ( inbresistor == 1 )	// avec cette condition on evite les aberances comme demander la resistance equivalante a une seul resistance ;)
		{
			system ("cls") ;

			printf ( "vous avez demander un calcul pour une seule resistance\n\n.....vous etes un idiot...\n\n" ) ;
		
			system ("pause") ;

			exit (-1) ;
		}

		//////////////////////////////////////////////////////////////////////
		// On initialise les tableau en leur alouant de la memoire			//
		// la memoire allouer depend directement de la taille du tableau	//
		// par exemple la valeur d'une resistance est sur un type double	//
		// donc on allou comme memoire la taille d'un double multiplié		//
		// par le nombre de valeur a entrer dans le tableau					//
		//////////////////////////////////////////////////////////////////////

		resistor = ( double*) malloc (sizeof (double) * inbresistor ) ; 
		G = (double*) malloc (sizeof (double) * inbresistor ) ;

		// on recupere dans cette boucle la valeur de chaque resistance

		for ( int i = 1; i <= inbresistor; i++ )

		{
			printf ( "veuillez entrer la valeur de la resistance R%d. \n\n", i ) ; 

			scanf ( "%lf", &resistor [i - 1] ) ;

			if ( resistor [i - 1] <= 0 ) // cette condition permet de se proteger d'une division par zero au moment du calcule la la resistance equivalante
			{
				system ("cls") ;

				printf ( "vous avez choisi une resistance de nulle ou negative\n\n...vous etes un idiot...\n\n" ) ;

				system ("pause") ;

				exit (-1) ;
			}
		}

		// On calcule la resistante equivalante pour des resistances en serie

		if ( ctype == '1' )
		{
			for ( int i = 1; i <= inbresistor; i++ )
			{
				Req = Req + resistor [i - 1] ; // n'oublier pas le -1 car le tableau à un index 0,
											   // le numero de resistance 1 corespond a l'index 0 du tableau
											   // donc le numero n corespond a l'index "n-1" ;)
			
			}
		
		}

		// On calcule la resistante equivalante pour des resistances en parallele

		else if ( ctype == '2' )
		{
			for ( int i = 1; i <= inbresistor; i++ )
			{
				G [i - 1] = 1/resistor [i - 1] ;

				dAd = dAd + G [i - 1] ;
			
			}
		
			Req = 1/dAd ;
		}

		dec = modf ( Req, &ent ) ;	// on recupere la partie decimale de la resistance equivalante

		if ( dec == 0 )				// si elle est nulle alors on affiche que la partie entiere
		{
			system ("cls") ;

			printf ("\n\nLa resistance equivalante est Req = %.0lf .\n\n", Req ); // ex : si Req = 22 on lira 22 et non pas 22.000000 ;)
		}
		else
		{

			sprintf (caff_resultat, "%lf", Req ) ; // ici on converti la valeur Req en chaine de caractere caff_resultat

			ilong = strlen (caff_resultat) ; //ilong recupere le nombre de caractere present dans la chaine

			for (int j = ilong - 1; j > 0; j--)	// on tronque les zero inutile de la partie decimale
			{
				if ( caff_resultat [j] == '0' )
				{
					caff_resultat [j] = '\0';
				}

				else
				{
					break ;
				}
			}
			system ("cls") ;

			printf ("\n\nLa resistance equivalante est Req = %s .\n\n", caff_resultat ) ;	// donc si la Req = 22.15 en affichan la chaine tronquée on lira 22.15 et non pas 22.150000
		
		}

		// ne pas oublier de liberer la memoire allouée

		free (resistor) ;
		free (G) ;

		system ("pause") ;	// petite pause avant le rebouclage au debut du code

	}

}

A voir également

Ajouter un commentaire

Commentaires

Commenter la réponse de Utilisateur anonyme

Vous n'êtes pas encore membre ?

inscrivez-vous, c'est gratuit et ça prend moins d'une minute !

Les membres obtiennent plus de réponses que les utilisateurs anonymes.

Le fait d'être membre vous permet d'avoir un suivi détaillé de vos demandes et codes sources.

Le fait d'être membre vous permet d'avoir des options supplémentaires.