Partage

[Exercices] Venez vous entraîner !

(v2)

1 août 2012 à 19:40:55

Citation : thejailbreakman3


Le projet doit contenir:

-main.cpp
-OlsApiInit.h
-OlsApiInitDef.h avec "#pragma once" et "#include <windows.h>"

-OlsDef.h avec "#pragma once"


:-°
Néanmoins, pour les Windowsiens, l'exercice est surement intéressant ;)
2 août 2012 à 0:18:18

mmh... je vais ajouter une catégorie librairie avec cet exercice dans la section API win.
2 août 2012 à 10:24:14

Je pense que c'est une bonne idée ;)
Mais je pense qu'il faudra équilibrer avec les autres catégories : pas plus de 4-5 exercices dans cette section ;) Car je pense que les propositions d'exercices sera plutôt énorme ;)
2 août 2012 à 11:00:49

Je la poste ou la solution?
2 août 2012 à 11:56:57

Ici, sous une balise secret si possible, car juste en dessous de l'exercice.
cf le premier post.
2 août 2012 à 14:09:24

Ok merci.
__________________________________________________________________________________
__________________________________________________________________________________


Correction de l'exercice: Température de processeur

__________________________________________________________________________________
__________________________________________________________________________________


Apparemment, mon programme a du mal avec les vieux processeurs, mais marche très bien sur les gammes i3, i5 et i7.


Si vous n'êtes pas arrivé a faire le programme, regardez rapidement sur la correction le bout de programme que vous n'avez pas compris puis réessayez, ainsi de suite...

J'aimerai aussi savoir si le programme tourne sur linux.

Voici sans plus attendre la correction:


Fichier cpp


main.cpp

Il n'y avait que un fichier cpp a mettre dans le projet.

#include "OlsApiInit.h"
#include <iostream>

using namespace std;

int main(){
	HMODULE test;
	if(InitOpenLibSys(&test))
	{
		cout << "Initialisation reussie : " << endl;

		cout << "******** Lecture Tj by Thejailbreakman3 ********" << endl;
		if(!IsCpuid())
		{
			cout << "CPUID non supporte !" << endl << "Fermeture de l'application !" << endl;
			DeinitializeOls();
			return 1;
		}
		if(!IsMsr())
		{
			cout << "MSR non supporte !" << endl << "Fermeture de l'application !" << endl;
			DeinitializeOls();
			return 1;
		}
		if(!IsTsc())
		{
			cout << "Time stamp counter non supporte !" << endl << "Fermeture de l'application !" << endl;
			DeinitializeOls();
			return 1;
		}

		bool continuer = true;
		do{
			DWORD eax1, edx1, eax2, edx2, eax3, edx3, eax4, edx4;
			RdmsrEx(0x0000019C, &eax1, &edx1, 1);
			RdmsrEx(0x0000019C, &eax2, &edx2, 1 << 1);
			RdmsrEx(0x0000019C, &eax3, &edx3, 1 << 2);
			RdmsrEx(0x0000019C, &eax4, &edx4, 1 << 3);

			eax1 &= 0x007F0000;
			eax2 &= 0x007F0000;
			eax3 &= 0x007F0000;
			eax4 &= 0x007F0000;

			eax1 = eax1 >> 16;
			eax2 = eax2 >> 16;
			eax3 = eax3 >> 16;
			eax4 = eax4 >> 16;

			int temp1 = 100 - ((int)eax1);
			int temp2 = 100 - ((int)eax2);
			int temp3 = 100 - ((int)eax3);
			int temp4 = 100 - ((int)eax4);

			cout << "Msr 19C : " << endl;
			cout << "\teax1 = " << -(int)eax1 << "\teax2 = " << -(int)eax2 << "\teax3 = " << -(int)eax3 << "\teax4 = " << -(int)eax4 << endl;

			cout << "\tTemp core 0 : " << temp1 << " degres" << endl;
			cout << "\tTemp core 1 : " << temp2 << " degres" << endl;
			cout << "\tTemp core 2 : " << temp3 << " degres" << endl;
			cout << "\tTemp core 3 : " << temp4 << " degres" << endl;
			cout << endl << "Continuer ? (O/N)";
			char valid;
			cin >> valid;
			if(valid!=79 && valid!=111)
				continuer=false;
		}while(continuer);

		if(DeinitOpenLibSys(&test))
			cout << "Desinitialisation reussie" << endl;
		else
			cout << "Desinitialisation ratee";
	}
	else
		cout << "Erreur, impossible d'initialiser WinRing0" << endl;
	system("PAUSE");
	return 0;
}


Fichiers headers



Nous avons trois headers: OlsApiInit.h, OlsApiInitDef.h et enfin OlsDef.h


OlsApiInit.h

Rien de bien particulier, il faut utiliser la bibliotheque pragma once
#pragma once

#include "OlsDef.h"
#include "OlsApiInitDef.h"

//-----------------------------------------------------------------------------
//
// Prototypes
//
//-----------------------------------------------------------------------------

BOOL InitOpenLibSys(HMODULE *hModule);
BOOL DeinitOpenLibSys(HMODULE *hModule);

//-----------------------------------------------------------------------------
//
// Funtions
//
//-----------------------------------------------------------------------------

// DLL
_GetDllStatus GetDllStatus = NULL;
_GetDllVersion GetDllVersion = NULL;
_GetDriverVersion GetDriverVersion = NULL;
_GetDriverType GetDriverType = NULL;

_InitializeOls InitializeOls = NULL;
_DeinitializeOls DeinitializeOls = NULL;

// CPU
_IsCpuid IsCpuid = NULL;
_IsMsr IsMsr = NULL;
_IsTsc IsTsc = NULL;

_Hlt Hlt = NULL;
_Rdmsr Rdmsr = NULL;
_Wrmsr Wrmsr = NULL;
_Rdpmc Rdpmc = NULL;
_Cpuid Cpuid = NULL;
_Rdtsc Rdtsc = NULL;

_HltEx HltEx = NULL;
_RdmsrEx RdmsrEx = NULL;
_WrmsrEx WrmsrEx = NULL;
_RdpmcEx RdpmcEx = NULL;
_CpuidEx CpuidEx = NULL;
_RdtscEx RdtscEx = NULL;

// I/O
_ReadIoPortByte ReadIoPortByte = NULL;
_ReadIoPortWord ReadIoPortWord = NULL;
_ReadIoPortDword ReadIoPortDword = NULL;

_ReadIoPortByteEx ReadIoPortByteEx = NULL;
_ReadIoPortWordEx ReadIoPortWordEx = NULL;
_ReadIoPortDwordEx ReadIoPortDwordEx = NULL;

_WriteIoPortByte WriteIoPortByte = NULL;
_WriteIoPortWord WriteIoPortWord = NULL;
_WriteIoPortDword WriteIoPortDword = NULL;

_WriteIoPortByteEx WriteIoPortByteEx = NULL;
_WriteIoPortWordEx WriteIoPortWordEx = NULL;
_WriteIoPortDwordEx WriteIoPortDwordEx = NULL;

// PCI
_SetPciMaxBusIndex SetPciMaxBusIndex = NULL;

_ReadPciConfigByte ReadPciConfigByte = NULL;
_ReadPciConfigWord ReadPciConfigWord = NULL;
_ReadPciConfigDword ReadPciConfigDword = NULL;

_ReadPciConfigByteEx ReadPciConfigByteEx = NULL;
_ReadPciConfigWordEx ReadPciConfigWordEx = NULL;
_ReadPciConfigDwordEx ReadPciConfigDwordEx = NULL;

_WritePciConfigByte WritePciConfigByte = NULL;
_WritePciConfigWord WritePciConfigWord = NULL;
_WritePciConfigDword WritePciConfigDword = NULL;

_WritePciConfigByteEx WritePciConfigByteEx = NULL;
_WritePciConfigWordEx WritePciConfigWordEx = NULL;
_WritePciConfigDwordEx WritePciConfigDwordEx = NULL;

_FindPciDeviceById FindPciDeviceById = NULL;
_FindPciDeviceByClass FindPciDeviceByClass = NULL;

// Memory
_ReadDmiMemory ReadDmiMemory = NULL;

#ifdef _PHYSICAL_MEMORY_SUPPORT
_ReadPhysicalMemory ReadPhysicalMemory = NULL;
_WritePhysicalMemory WritePhysicalMemory = NULL;
#endif

//-----------------------------------------------------------------------------
//
// Initialize
//
//-----------------------------------------------------------------------------

BOOL InitOpenLibSys(HMODULE *hModule)
{
#ifdef _M_X64
	*hModule = LoadLibrary("WinRing0x64.dll");
#else
	*hModule = LoadLibrary("WinRing0.dll");
#endif

	if(*hModule == NULL)
	{
		return FALSE;
	}

	//-----------------------------------------------------------------------------
	// GetProcAddress
	//-----------------------------------------------------------------------------
	// DLL
	GetDllStatus =			(_GetDllStatus)			GetProcAddress (*hModule, "GetDllStatus");
	GetDllVersion =			(_GetDllVersion)		GetProcAddress (*hModule, "GetDllVersion");
	GetDriverVersion =		(_GetDriverVersion)		GetProcAddress (*hModule, "GetDriverVersion");
	GetDriverType =			(_GetDriverType)		GetProcAddress (*hModule, "GetDriverType");

	InitializeOls =			(_InitializeOls)		GetProcAddress (*hModule, "InitializeOls");
	DeinitializeOls =		(_DeinitializeOls)		GetProcAddress (*hModule, "DeinitializeOls");

	// CPU
	IsCpuid =				(_IsCpuid)				GetProcAddress (*hModule, "IsCpuid");
	IsMsr =					(_IsMsr)				GetProcAddress (*hModule, "IsMsr");
	IsTsc =					(_IsTsc)				GetProcAddress (*hModule, "IsTsc");
	Hlt =					(_Hlt)					GetProcAddress (*hModule, "Hlt");
	Rdmsr =					(_Rdmsr)				GetProcAddress (*hModule, "Rdmsr");
	Wrmsr =					(_Wrmsr)				GetProcAddress (*hModule, "Wrmsr");
	Rdpmc =					(_Rdpmc)				GetProcAddress (*hModule, "Rdpmc");
	Cpuid =					(_Cpuid)				GetProcAddress (*hModule, "Cpuid");
	Rdtsc =					(_Rdtsc)				GetProcAddress (*hModule, "Rdtsc");
	HltEx =					(_HltEx)				GetProcAddress (*hModule, "HltEx");
	RdmsrEx =				(_RdmsrEx)				GetProcAddress (*hModule, "RdmsrEx");
	WrmsrEx =				(_WrmsrEx)				GetProcAddress (*hModule, "WrmsrEx");
	RdpmcEx =				(_RdpmcEx)				GetProcAddress (*hModule, "RdpmcEx");
	CpuidEx =				(_CpuidEx)				GetProcAddress (*hModule, "CpuidEx");
	RdtscEx =				(_RdtscEx)				GetProcAddress (*hModule, "RdtscEx");

	// I/O
	ReadIoPortByte =		(_ReadIoPortByte)		GetProcAddress (*hModule, "ReadIoPortByte");
	ReadIoPortWord =		(_ReadIoPortWord)		GetProcAddress (*hModule, "ReadIoPortWord");
	ReadIoPortDword =		(_ReadIoPortDword)		GetProcAddress (*hModule, "ReadIoPortDword");

	ReadIoPortByteEx =		(_ReadIoPortByteEx)		GetProcAddress (*hModule, "ReadIoPortByteEx");
	ReadIoPortWordEx =		(_ReadIoPortWordEx)		GetProcAddress (*hModule, "ReadIoPortWordEx");
	ReadIoPortDwordEx =		(_ReadIoPortDwordEx)	GetProcAddress (*hModule, "ReadIoPortDwordEx");

	WriteIoPortByte =		(_WriteIoPortByte)		GetProcAddress (*hModule, "WriteIoPortByte");
	WriteIoPortWord =		(_WriteIoPortWord)		GetProcAddress (*hModule, "WriteIoPortWord");
	WriteIoPortDword =		(_WriteIoPortDword)		GetProcAddress (*hModule, "WriteIoPortDword");

	WriteIoPortByteEx =		(_WriteIoPortByteEx)	GetProcAddress (*hModule, "WriteIoPortByteEx");
	WriteIoPortWordEx =		(_WriteIoPortWordEx)	GetProcAddress (*hModule, "WriteIoPortWordEx");
	WriteIoPortDwordEx =	(_WriteIoPortDwordEx)	GetProcAddress (*hModule, "WriteIoPortDwordEx");

	// PCI
	SetPciMaxBusIndex =		(_SetPciMaxBusIndex)	GetProcAddress (*hModule, "SetPciMaxBusIndex");

	ReadPciConfigByte =		(_ReadPciConfigByte)	GetProcAddress (*hModule, "ReadPciConfigByte");
	ReadPciConfigWord =		(_ReadPciConfigWord)	GetProcAddress (*hModule, "ReadPciConfigWord");
	ReadPciConfigDword =	(_ReadPciConfigDword)	GetProcAddress (*hModule, "ReadPciConfigDword");

	ReadPciConfigByteEx =	(_ReadPciConfigByteEx)	GetProcAddress (*hModule, "ReadPciConfigByteEx");
	ReadPciConfigWordEx =	(_ReadPciConfigWordEx)	GetProcAddress (*hModule, "ReadPciConfigWordEx");
	ReadPciConfigDwordEx =	(_ReadPciConfigDwordEx)	GetProcAddress (*hModule, "ReadPciConfigDwordEx");

	WritePciConfigByte =	(_WritePciConfigByte)	GetProcAddress (*hModule, "WritePciConfigByte");
	WritePciConfigWord =	(_WritePciConfigWord)	GetProcAddress (*hModule, "WritePciConfigWord");
	WritePciConfigDword =	(_WritePciConfigDword)	GetProcAddress (*hModule, "WritePciConfigDword");

	WritePciConfigByteEx =	(_WritePciConfigByteEx)	GetProcAddress (*hModule, "WritePciConfigByteEx");
	WritePciConfigWordEx =	(_WritePciConfigWordEx)	GetProcAddress (*hModule, "WritePciConfigWordEx");
	WritePciConfigDwordEx =	(_WritePciConfigDwordEx)GetProcAddress (*hModule, "WritePciConfigDwordEx");

	FindPciDeviceById =		(_FindPciDeviceById)	GetProcAddress (*hModule, "FindPciDeviceById");
	FindPciDeviceByClass =	(_FindPciDeviceByClass)	GetProcAddress (*hModule, "FindPciDeviceByClass");

	// Memory
	ReadDmiMemory =			(_ReadDmiMemory)		GetProcAddress (*hModule, "ReadDmiMemory");

#ifdef _PHYSICAL_MEMORY_SUPPORT
	ReadPhysicalMemory =	(_ReadPhysicalMemory)	GetProcAddress (*hModule, "ReadPhysicalMemory");
	WritePhysicalMemory =	(_WritePhysicalMemory)	GetProcAddress (*hModule, "WritePhysicalMemory");
#endif

	//-----------------------------------------------------------------------------
	// Check Functions
	//-----------------------------------------------------------------------------
	if(!(
		GetDllStatus
	&&	GetDllVersion
	&&	GetDriverVersion
	&&	GetDriverType
	&&	InitializeOls
	&&	DeinitializeOls
	&&	IsCpuid
	&&	IsMsr
	&&	IsTsc
	&&	Hlt
	&&	HltEx
	&&	Rdmsr
	&&	RdmsrEx
	&&	Wrmsr
	&&	WrmsrEx
	&&	Rdpmc
	&&	RdpmcEx
	&&	Cpuid
	&&	CpuidEx
	&&	Rdtsc
	&&	RdtscEx
	&&	ReadIoPortByte
	&&	ReadIoPortWord
	&&	ReadIoPortDword
	&&	ReadIoPortByteEx
	&&	ReadIoPortWordEx
	&&	ReadIoPortDwordEx
	&&	WriteIoPortByte
	&&	WriteIoPortWord
	&&	WriteIoPortDword
	&&	WriteIoPortByteEx
	&&	WriteIoPortWordEx
	&&	WriteIoPortDwordEx
	&&	SetPciMaxBusIndex
	&&	ReadPciConfigByte
	&&	ReadPciConfigWord
	&&	ReadPciConfigDword
	&&	ReadPciConfigByteEx
	&&	ReadPciConfigWordEx
	&&	ReadPciConfigDwordEx
	&&	WritePciConfigByte
	&&	WritePciConfigWord
	&&	WritePciConfigDword
	&&	WritePciConfigByteEx
	&&	WritePciConfigWordEx
	&&	WritePciConfigDwordEx
	&&	FindPciDeviceById
	&&	FindPciDeviceByClass
	&&	ReadDmiMemory
#ifdef _PHYSICAL_MEMORY_SUPPORT
	&&	ReadPhysicalMemory
	&&	WritePhysicalMemory
#endif
	))
	{
		return FALSE;
	}

	return InitializeOls();
}

//-----------------------------------------------------------------------------
//
// Deinitialize
//
//-----------------------------------------------------------------------------

BOOL DeinitOpenLibSys(HMODULE *hModule)
{
	BOOL result = FALSE;

	if(*hModule == NULL)
	{
		return TRUE;
	}
	else
	{
		DeinitializeOls();
		result = FreeLibrary(*hModule);
		*hModule = NULL;

		return result;
	}
}







Télécharger le zip complet avec les dll



Cette source est l'un des points de départ que j'ai créé pour lire les informations bas niveau du processeur. La source a été testée et validé sur un certains nombres de processeur, au minimum je garanti sur Core 2 + Phenom.

Ce projet est assez vieux (tout comme la lecture de la fréquence processeur), il utilise lui aussi WinRing0 + MSR pour lire une information nommée "Tj" qui est un indicateur fournit par le processeur indiquant la distance entre 100° (ou 75° suivant les processeurs) et sa température actuelle.

Par exemple, on peut obtenir -59°, ce qui indique que le processeur se trouve actuellement à 100 - 59, soit 41°.

Si mes souvenirs sont bon, Tj est apparut sur les premiers Intel Core, et l'équivalent AMD, il est encore d'actualité sur les derniers Core 7/Atom.

Techniquement, ce système est la base utilisé par des programmes comme Real Temp ou CoreTemp.
2 août 2012 à 14:16:03

Citation : thejailbreakman3

Cette source est l'un des points de départ que j'ai créé



Ou merci cs.com ?
4 septembre 2012 à 21:52:32

Bonjour

Précédemment sur ce topic, j'ai proposé un exercice portant sur la création d'un logiciel permettant de calculer la moyenne d'une série de nombre et plus particulièrement pour des notes. Je propose ce mois ci sur mon site le même exercice un peu amélioré et une correction en 4 partie qui apparaîtront au fil du mois.
Cette correction est en C++ et en diaporama sur Google Document et la première partie est publié et elle porte surtout sur les pré-requis. Voici la suite :
  • Après il y aura un diapo sur comment calculer la moyenne d'une série de notes classé par matières (on calcule d'abord chaque moyenne de chaque matière puis on fait la moyenne de toute les maatières.
  • Après, on met un coefficient pour les notes.
  • Après, on met un coefficient pour les matières.

Cela fait en tout une cinquantaine de diapo avec toute la progression détaillé.

Voilà
jérémie 14
Venez découvrir mon site, madgic système.
11 novembre 2012 à 22:34:51

Bonjour,

Un petit exercice supplémentaire que j'ai eu à faire pour mes cours en Java. Mais en C++ c'est pareil ou n'importe quelle langage. Pour ma part, il fallut que je le fasse d'abord avec Algobox : c'était comique et plus dur qu'avec Eclipse mais bon...
C'est un convertisseur.

But du jeu :
On rentre un nombre binaire, décimal ou hexadécimal et il faut convertir le nombre dans les deux autre types. Et bien sûr sans utiliser les fonctions toutes faîtes mais en utilisant que les types de variables de base... Essayez d'abord avec les nombres entiers positifs puis négatifs puis décimaux...

Voilà
Sa s'adresse à tous
jérémie 14
Venez découvrir mon site, madgic système.
11 novembre 2012 à 23:32:10

Une vieille correction (qui vaut ce quelle vaut)
-> http://www.siteduzero.com/forum-83-471 [...] html#r4468889
C++: Blog|FAQ C++ dvpz|FAQ fclc++|FAQ Comeau|FAQ C++lite|FAQ BS| Bons livres sur le C++| PS: Je ne réponds pas aux questions techniques par MP.
6 décembre 2012 à 21:26:13

Exercice : Bataille Navale en console


Pour ceux qui ont du temps à perdre comme moi, je propose de tenter de coder un jeu de bataille navale :pirate:

------------------------
    Bataille navale
------------------------

Generation d'une grille pour l'utilisateur...
Generation terminee !
Appuyez sur entree pour commencer...

Vous jouez - Entrez une coordonnee (LETTRECHIFFRE)
A3
L'ordinateur : Dans l'eau !
L'ordinateur joue : D5
Vous : Dans l'eau !
Vous jouez - Entrez une coordonnee (LETTRECHIFFRE)
_


Voici au moins à ce quoi il faudra penser :
  • La bataille navale se compose normalement de :
  • -1 porte-avion (5 cases)
  • -1 croiseur (4 cases)
  • -1 contre-torpilleur (3 cases)
  • -1 torpilleur (2 cases)
  • -1 sous-marin (1 case)
  • Lorsqu'on touche, on rejoue.
  • Respecter la règle des coordonnées de la bataille navale : Une lettre et un chiffre.
  • Créer une grille pour les deux joueurs : L'utilisateur et l'ordinateur
  • Les navires entièrement détruits envoient "coulé !".
  • Le jeu demande à l'utilisateur une taille pour le tableau supérieure à 5 cases (1 porte-avion), de plus, il ne peut pas excéder 26 cases (L'alphabet, en fait), puisque l'une des coordonnées est une lettre.
  • Les navires sont placés aléatoirement, et ne doivent pas sortir de la grille.
  • Le jeu s'arrête lorsque tous les navires d'un joueur ont été détruits.
  • L'ordinateur n'est pas (si) stupide, faites en sorte que lorsqu'il touche un bâtiment, il ait l'intelligence de faire un coup à proximité.

Pour vous aider, voici une floppée d'indices pour mener à bien cette tâche inutile :

Indice 1 :

Il faudra commencer par créer la grille !
pour cela, on peut très bien se contenter d'un tableau de int :
bool grilleDeMonOrdi[10][10];

Pourquoi des bool ? Parce que c'est plus simple de s'en servir et ils ne prennent que deux valeurs : true ou false. Dans notre situation, une case du tableau sera true si elle est une partie d'un navire.

Indice 2 :

Comme vous le voyez sur mon exemple plus haut, on entre deux coordonnées...mais l'un est en lettres !
Il vous faudra donc ruser et créer un second tableau qui sera utilisé pour comparer les lettres :
char monTableau[26] = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
//Un tableau de char est une chaîne de caractères !

Et pour tester la lettre, on fera une boucle :
string choix("A5"); //Les coordonnées entrées par l'utilisateur
int position1(-1); //L'axe x qu'il faudra tester - Cette valeur nous dira si le caractère récupéré n'est pas une lettre
for (int i = 0; i < monTableau.size(); i++)
{
    if (choix[0] == monTableau[i]) //Rappel : Un tableau commence par 0 et string est (presque) un tableau de char
    {
        position1 = i; //On récupère la valeur de la lettre entrée
        break;
    }
}
//En sortant de la boucle, position1 a deux valeurs possibles : Soit celle de la case du tableau, soit -1, qui signifie que la lettre n'a pas été trouvée
if (position1 == -1)
{
    cout << "Erreur - Coordonnee invalide"
}

Indice 3 :

Vous avez lu l'indice 2 ? Parce que j'ai volontairement omis quelques détails...
Vous ne voyez pas...?
...
Le tableau est sensible à la casse !
Sensible à la casse signifie que pour l'ordinateur, 'A' et 'a', c'est pas la même chose !

Pour régler ce petit problème, il vous faudra l'en-tête suivant :
#include <cctype>

Et rajouter ceci dans notre petite boucle de l'indice 2 :
#include <cctype> //On n'oublie pas !!!
#include <string> //Puisqu'on est dans les #include, autant tous les mettre.

using namespace std; //Idem.

string choix("a5"); //Les coordonnées entrées par l'utilisateur
int position1(0); //L'axe x qu'il faudra tester
choix[0] = toupper(choix[0]); //Rend le premier élément du tableau majuscule
for (int i = 0; i < monTableau.size(); i++)
{
    if (choix[0] == monTableau[i])
    {
        position1 = i; //On récupère la valeur de la lettre entrée
        break;
    }
}

Indice 4 :

Ici, on va s'attaquer à l'aléatoire !
Bon, je vais pas vous donner la solution, je vais juste vous montrer comment on s'en sert :
#include <cstdlib> //Important !!!
#include <ctime> //Important aussi !!!

using namespace std;

srand(time(0));
int const tailleTableau(12); //Bon, on veut un nombre aléatoire pour un tableau de cette taille
int nombreAleatoire = rand() % tailleTableau;

Et voilà ! srand(time(0)) "initialise" notre futur nombre aléatoire, et rand() % tailleTableau nous renvoie ce nombre aléatoire compris entre 0 et tailleTableau.

Indice 5 :

Voici quelques conseils en pagaille :
  • Faites attention de ne pas chercher une valeur du tableau qui n'existe pas ! Pour ça, testez ce que rentre l'utilisateur !
  • Les navires sont des objets, rappelez-vous en ! Vous verrez que pour le conseil suivant, vérifier les différentes parties de l'objet sera plus facile que de le faire à l'arrache dans une énorme fonction.
  • Pour créer cette pseudo-intelligence artificielle qui va tirer à proximité d'un "touché", il faudra que votre ordinateur fasse littéralement "coordonnée précédente +1 case vers une autre direction", et si ce coup est "dans l'eau", changer de direction. Une fois que le navire est coulé (on vérifie toute ses parties par une méthode), l'ordinateur se remettra à tirer aléatoirement.
  • N'hésitez pas à créer un tableau dynamique (ou un tableau statique de la même taille que la grille)qui contiendra toutes les coordonnées déjà essayées par l'ordinateur et l'utilisateur, afin que les deux évitent de refaire les mêmes coordonnées en boucle (surtout l'ordinateur : Il n'est pas très...intelligent).

Pour ceux qui veulent aller plus loin...


Si vous ne trouvez pas le défi suffisamment gourmand, je vous propose une liste de plus à votre bataille navale :

Faites en sorte que la console affiche la grille de l'utilisateur et la grille de l'ordinateur qu'on a déjà essayé (rentré les coordonnées). La grille de l'utilisateur affiche l'état des bâtiments, la grille et les coordonnées, celle de l'ordinateur juste la grille, les coordonnées et les bâtiments touchés.
Exemple :
Votre grille :
  A  B  C  D  E  F  G  H  I
1[ ][ ][ ][ ][ ][ ][ ][x][ ]
2[o][ ][ ][o][ ][ ][ ][x][ ]
3[o][ ][ ][o][ ][ ][ ][ ][ ]
4[x][ ][ ][o][ ][ ][ ][ ][ ]
5[ ][ ][ ][ ][ ][ ][ ][ ][ ]
6[ ][ ][ ][ ][ ][ ][ ][ ][ ]
7[ ][ ][ ][o][o][o][o][ ][ ]
8[ ][ ][ ][ ][ ][ ][ ][ ][ ]
9[x][x][x][x][x][ ][ ][ ][ ]

Nombre de batiments : 5
Nombre de batiments detruits : 2
Nombre de x : 8
Nombre de o : 9
Score actuel : 6 contre 8

Comme vous pouvez le voir, n'hésitez pas à afficher des informations utiles en dessous !

Ensuite, essayez de dépasser cette limite de 26 cases en créant un système qui va séparer toutes les lettres et tous les chiffres : Par exemple, la colonne numéro 27 aura pour coordonnée AA et la ligne 87 (je suis fou !), ben 87.

Vu qu'on va dépasser cette limite de 26 cases, la grille va légèrement être décalée par rapport à sa numérotation : Trouvez un moyen de contourner ce pépin.
Exemple concret pour un tableau à 26+26+26 cases (3 lettres comme coordonnées maximum) :
AAA AAB AAC AAD AAE AAF
98[x][ ][ ][ ][ ][ ]
99[o][ ][ ][ ][ ][ ]
100[o][ ][ ][ ][ ][ ]

La console n'est pas élastique, si vous en faites trop, la console ne va pas pouvoir afficher l'intégralité du tableau et fera un "vieux" retour à la ligne, pour cela, trouvez un moyen de tronquer le tableau en plusieurs bouts affichables correctement dans cette antiquité.


Soyez encore plus fou : Autorisez le déplacement des navire !
Créez un système de gestion entièrement en console qui vous permettra de sélectionner un navire et de le faire bouger dans une direction !
En contrepartie, l'ordinateur en face peut faire de même, c'est pourquoi il faudra créer une autre intelligence artificielle capable de sélectionner et déplacer un navire en mauvaise posture.
Faites attention à ne pas sortir de la grille, pour cela, je propose que lorsque le navire "sors" dans un bord, il réapparaisse sur la ligne suivante, enfin, innovez.
Bien sûr, il n'est pas possible de déplacer des navires détruits, ou même, rajoutez une option qui fait que si votre navire est détruit à plus de 50%, il est dans l'incapacité de se déplacer !

Complexifiez encore plus, on peut aller plus loin : Lorsque qu'un navire bouge, il est détecté par les radars de l'ennemi : Vous (ou l'ordinateur) recevez un intervalle de tir dans lequel un bateau est susceptible de se trouver.

Le bout de la bataille navale, c'est de créer tout simplement le jeu concret : Une grille et des navires qui s'affrontent...dans la console...C'est bizzare mais faisable pourtant, il faut juste avoir beaucoup de temps à perdre.

A propos de ces "objets"...


Cette partie est réservée à ceux qui ne voient pas pourquoi je parle d'objets.

On parle d'objets parce qu'un navire, c'est plusieurs éléments susceptibles de changer durant la partie. Ces éléments ont deux coordonnées : l'axe x et l'axe y dans le tableau. Ce sont les attributs.
Pour voir si le navire a coulé, on a juste à voir si tous les éléments du navire sont détruits.
Pour déplacer le navire, il suffit d'ajouter ou de soustraire le même nombre aux attributs.
Pour récupérer un intervalle, il suffit de faire une moyenne sur une marge d'erreur avec les attributs.
Au final, j'ai déjà écrit trois méthodes grossières.

A vous de faire le reste !

Le mot de la fin


Je mettrais à jour ce message selon ce qui me viendra à l'esprit, puis je posterais une solution de l'exercice lorsque j'aurais réussi moi-même à le faire, soit dans...longtemps :-°
Anonyme
15 décembre 2012 à 11:06:48

Pas mal... ça change un peu, un vrai exercice.
Mais juste un truc, pour répondre aux indices 2 et 3 :
Plutôt que de faire un gros tableau, et de tout tester (d'ailleurs, tu devrais plutôt remplir ton tableau avec une chaîne de caractères : char tableau[27] = "abcdefghijklmnopqrstuvwxyz";. Enfin, c'est à mon avis plus propre. D'ailleurs, si tu commences les indices à 1 (cf ton remplissage) il faut rester cohérent, rajouter une case au tableau pour que tout tienne, et adapter ta boucle)
Tu pourrais partir du postulat que, sur la très grande majorité des ordis, 'b' = 'a' + 1, etc.
Du coup, on a la correspondance :
int toNumber(char c) // 'a' = 0. Rajouter 1 si on veut (mauvaise idée à mon avis)
{
    if ('a' <= c && c <= 'z')
        return c - 'a';
    if ('A' <= c && c <= 'Z')
        return c - 'A';
    
    // Erreur : c n'est pas une lettre
}

char toLetter(int n)
{
    if (0 <= n && n < 26)
        return n + 'A';
    
    // Erreur : n n'est pas représentable par une lettre.
}

C'est plus simple, plus compréhensible, plus rapide, moins bogué, et ça marche presque partout (les personnes ayant un ordi pour lequel ça ne marche pas en sont totalement au courant, en plus d'être rarissimes)
15 décembre 2012 à 11:33:51

Citation : Hugooguh

Pas mal... ça change un peu, un vrai exercice.
Mais juste un truc, pour répondre aux indices 2 et 3 :

Plutôt que de faire un gros tableau, et de tout tester (d'ailleurs, tu devrais plutôt remplir ton tableau avec une chaîne de caractères : char tableau[27] = "abcdefghijklmnopqrstuvwxyz";. Enfin, c'est à mon avis plus propre. D'ailleurs, si tu commences les indices à 1 (cf ton remplissage) il faut rester cohérent, rajouter une case au tableau pour que tout tienne, et adapter ta boucle)
Tu pourrais partir du postulat que, sur la très grande majorité des ordis, 'b' = 'a' + 1, etc.
Du coup, on a la correspondance :
int toNumber(char c) // 'a' = 0. Rajouter 1 si on veut (mauvaise idée à mon avis)
{
    if ('a' <= c && c <= 'z')
        return c - 'a';
    if ('A' <= c && c <= 'Z')
        return c - 'A';
    
    // Erreur : c n'est pas une lettre
}

char toLetter(int n)
{
    if (0 <= n && n < 26)
        return n + 'A';
    
    // Erreur : n n'est pas représentable par une lettre.
}

C'est plus simple, plus compréhensible, plus rapide, moins bogué, et ça marche presque partout (les personnes ayant un ordi pour lequel ça ne marche pas en sont totalement au courant, en plus d'être rarissimes)


A chaque fois je me fais avoir et j'oublie que les tableaux de char sont des chaînes de caractère ^^
Je corrige !

EDIT : J'ai pas tout pigé, si ce n'est que non, je ne commence pas par l'indice 1, je teste bêtement la lettre au tableau, avec un for, C'est clair, rapide, précis, et on sort de la boucle si la lettre n'est pas trouvée. J'y pense, je n'ai pas mis la gestion de cette erreur :-°
Anonyme
17 décembre 2012 à 20:35:55

D'accord, si tu ne veux pas aborder ça, c'est un choix...
C'est souvent pratique de supposer que les lettres entre 'a' et 'z' se suivent. Mais vu que c'est pas très clair, et pas toujours vrai, je ne peux pas te le reprocher.

Par contre :
monTableau est un tableau normal, tu ne peux pas faire "monTableau.size()"... Il faut mettre un chiffre "en dur", ou alors un #define.
Et puis, pour l'indice 3, j'aurais simplement dit qu'il faut faire un toupper(), c'est plus concis, et ça évite les erreurs de copier-collé (tu n'as pas implémenté ta gestion d'erreurs dans l'indice 3.

Pour l'indice 4, je préciserai aussi qu'il ne faut initialiser l'aléatoire qu'une seule fois, au début du main par exemple. On ne le répète jamais assez. Au pire, mets un lien vers le (très bon) tuto SDZ sur le sujet...
26 mars 2013 à 16:46:22

NB: Les liens ont péter lors de la migration v4, il va falloir les corriger.
C++: Blog|FAQ C++ dvpz|FAQ fclc++|FAQ Comeau|FAQ C++lite|FAQ BS| Bons livres sur le C++| PS: Je ne réponds pas aux questions techniques par MP.
26 mars 2013 à 20:57:19

Ouch ><

Et évidemment idem pour le sujet de Nanoc...

Vais voir ça quand j'aurai du temps devant moi... :/

26 mars 2013 à 23:27:41

germino: Remis d'aplomb tous les liens vers le topic de Nanoc... Pfiu !

A faire : remettre tous les autres liens morts

5 mai 2013 à 13:20:55

Bonjour à tous,

Voilà l'exercice que je propose:

(Je me suis permis de guider l'utilisateur afin que la réalisation du code soit plus simple.)

Sujet: Base de données

L'objectif est de réaliser des traitements sur l’ensemble des salles disponibles au sein

d'une université par une application C++. Pour chaque salle on souhaite avoir les informations

suivantes :

1) leur localisation : une chaîne de caractères (« P407 »)

2) leur capacité : un entier

3) la présence ou non d’un vidéoProjecteur.

4) La réservation : une chaîne de caractères correspondant au nom de l’enseignant

ou « inconnu ».

5) Le tableau des enseignants autorisés à réserver.

1.1) Ecrire la classe Salle avec ces attributs et ses constructeurs : 1) par défaut une

salle a des valeurs par défaut pour chacun de ses attributs respectivement LocalisationDefaut,

capaciteDefault et ne possède pas de vidéoprojecteur ; 2) un constructeur pour initialiser

chacun de ces attributs.

Chaque attribut (sauf capaciteDefault) doit pouvoir être modifié sachant que le nombre de

places ne peut jamais être supérieur à capaciteDefault dans le cas contraire la valeur est

capaciteDefault. Des accesseurs seront également prévus pour la liste des enseignants.

1.2) Ajouter une méthode String toString() retournant la chaîne de caractères

suivantes :

« la salle : » localisation « contient : » capacité « places » et « un videoprojecteur »| « pas de

videoprojecteur » « , elle est » « réservée »| « non réservée ».

1.3) Ecrire la fonction booléenne isHabilite(String Enseignant) qui retourne vrai si le

nom de l’enseignant est dans la liste des habilités.

1.4) Ajouter la fonction boolean reservationPossible(String nomEnseignant, int

nombrePlace, boolean video) qui retourne vrai si si le nombre de places (nombrePlace)

est inférieure à la capacité de la salle, que l’enseignant est autorisé à réserver et que la salle

possède un videoprojecteur s’il est requis.

Ajouter une seconde classe Etage:

La classe Etage doit gérer un vecteur de salles. Ecrire les fonctions pour :

1) gérer la liste des salles : ajouter, retirer et retourner une salle,

2) trouver une salle disponible,

3) réserver une salle,

4) calculer la capacité d’accueil de l’étage

5) calculer le pourcentage de disponibilité.

6) Retourner l’état courant de l’étage en tant que String.

Bon courage!

19 octobre 2013 à 11:29:09

Hello ^^

Aujourd'hui j'étais motivé alors j'ai cherché les liens vers les exercices de ce topic!

Voici la liste (normalement je n'ai oublié personne...) :

 Il me semble que certains des exercices que j'ai trouvé (dans les derniers) n'étaient pas sur le 1e post, mais comme je les ai trouvé intéressants je les ai ajoutés également à la liste.

 PS : je n'ai pas pris de liens pour les corrections, mais en cherchant un peu les visiteurs devraient en trouver une ou 2 après le sujet d'exo ;)

-
Edité par nours59 19 octobre 2013 à 11:33:53

19 octobre 2013 à 23:20:41

Merci Nours, je prendrai le temps de les intégrer quand j'aurai un moment de libre :).
31 octobre 2013 à 19:21:18

salut tout le monde ici :)

voila je suis totalement débutant dans le monde la programmation et j'aimerai savoir ce que vos penser de ma version de biblio++ , histoire d'amélioré tout ça, a savoir qu'a l'heur ou je écris ici ne j en suis qu'a "Programmez avec le langage C partis 2 fins de " l'héritage" début " polymorphisme" et j'ai vaguement survolé le chapitre qui parle de QT et attention aux fautes dsl je sais sa pique les yeux : s

comme vous pouvez le voir j'ai pour projet de l'adapter à mes besoin gestion K7 vidéo DVD etc :)

main.h

#include <iostream>
#include <fstream>
#include "menuConsole.h"


using namespace std;


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

ofstream fluxLogMenu("log.txt");

fluxLogMenu<<"lancement de biblio++"<<endl;
;

cout<<"bienvenue dans biblio++ gestion de mediatheque"<<endl<<endl<<endl;

MenuConsol Menu1;
Menu1.MenuPrincipal();

fluxLogMenu<<"fermeture de biblio++"<<endl;
return 0 ;
}



menuConsole.h

include <string>
#include "livre.h"

class MenuConsol
{
public:

MenuConsol();
void MenuPrincipal();
void MenuLivre();

private:

int ID,IDmembre;
int choixMenuPrincipal,choixMenuLivre,choixMenuDvd,choixMenuJeux,choixMenuK7;

std::string fichierLivre,fichierDvd;
std::string fichierJeux,fichierK7;

std::string titre,auteur,genre;
std::string nom, prenom;


LivreList *Livre =NULLL;


};

#endif

menuConsol.cpp

#include <iostream>
#include <fstream>
#include <string>
#include "menuConsole.h"

using namespace std;

MenuConsol::MenuConsol()
{
fichierLivre = "data/livre.biblio";
fichierDvd = "data/dvd.biblio";
fichierJeux = "data/jeux.biblio";
fichierK7 = "data/k7.biblio";
choixMenuLivre=0,choixMenuDvd=0,choixMenuJeux=0,choixMenuK7=0,choixMenuPrincipal =0;
Livre = new LivreList(fichierLivre);
} void MenuConsol::MenuLivre()
{

int i(1);
do{
cout<<"quel voulez vous faire ?"<<endl<<endl<<endl<<"1:Afficher d'un livre"<<endl<<"2:Ajouter un livre"<<endl<<"3:Supprimer un livre"<<endl<<"4:Modifier les données d'un livre"<<endl<<"5:afficher la Biliotheque"<<endl;
cout<<"6:ajouter un membre"<<endl<<"7:Afficher la liste des livres empruntés par un membre"<<endl<<"8:enprunter"<<endl<<"9:rendre"<<endl<<"0:retour au menu principal"<<endl<<endl;
cin>>choixMenuLivre;

if(choixMenuLivre == 1)
{// affiche livre
cout<<"taper l'ID du livre a afficher"<<endl;
cin>>ID;
Livre->LireFichier();
Livre->afficherObjet(ID);
}

if(choixMenuLivre == 2)
{// ajoute livre
cout<<endl<<"vous avez choisis d ajouter un livre"<<endl<<"enter le nom du livre"<<endl;
cin>>titre;
cout<<"enter le nom de l auteur"<<endl;
cin>>auteur;
cout<<"enter le genre du livre"<<endl;
cin>>genre;
Livre->LireFichier();
Livre->ajouteObjet(titre,auteur,genre);
}

if(choixMenuLivre == 3)
{
// suprimer livre
cout<<"quel livre voulez vous supprimer"<<endl;
cin>>ID;
Livre->LireFichier();
Livre->deleteObjet(ID);//suprime un livre
}

if(choixMenuLivre == 4)
{
//modifier les donne livre
cout<<"taper l'ID du livre a modifier"<<endl;
cin>>ID;
Livre->LireFichier();
Livre->modifierObjet(ID);
Livre->saveListe();
}

if(choixMenuLivre == 5)
{ //afficher media
Livre->LireFichier();
Livre->afficheListObjet();
}

if(choixMenuLivre == 6)
{// ajoute un membre
cout<<endl<<"vous avez choisis d ajouter du nouveau Membre"<<endl;
cout<<"enter le nom du nouveau Membre"<<endl;
cin>>nom;
cout<<"enter le prenom du nouveau Membre"<<endl;
cin>>prenom;
Livre->Membre->LireFichierMembre();
Livre->Membre->ajouteMembre(nom,prenom);
}

if(choixMenuLivre ==7)
{// affiche la liste des objet enpruinter par menbre

cout<<endl<<"vous avez choisis d afficher la liste des objet louer par ce Membre"<<endl;
cout<<"enter l'ID du Membre"<<endl;
cin>>IDmembre;
Livre->LireFichier();
Livre->Membre->LireFichierMembre();
Livre->afficheObjetEmprunter(IDmembre);
}

if(choixMenuLivre ==8)
{// enprunter


cout<<endl<<"vous avez choisis d'enprunter un objet"<<endl;
cout<<"enter l'ID Objet"<<endl;
cin>>ID;
cout<<"enter l'ID Membre"<<endl;
cin>>IDmembre;
Livre->LireFichier();
Livre->Membre->LireFichierMembre();
Livre->enprunterObjet(IDmembre,ID);
Livre->Membre->savelisteMembre();
Livre->saveListe();
}

if(choixMenuLivre ==9)
{// rendre

cout<<endl<<"vous avez choisis de rendre un objet"<<endl;
cout<<"enter l'ID Objet"<<endl;
cin>>ID;
cout<<"enter l'ID Membre"<<endl;
cin>>IDmembre;
Livre->Membre->LireFichierMembre();
Livre->LireFichier();
Livre->rendreObjet(IDmembre,ID);
Livre->saveListe();
}

if(choixMenuLivre ==0)
{
i--;
}

}while(i);

MenuPrincipal();
}

 objet.h

#ifndef DEF_OBJET
#define DEF_OBJET
#include <iostream>
#include <fstream>
#include <string>
#include <vector>
#include "membre.h"

class ObjetList
{

    public:

    ObjetList();
    ObjetList(std::string fichier);
    void LireFichier();
    void ajouteObjet(std::string titre, std::string auteur, std::string genre);
    int rechercheObjet(int IDrechercher);
    int rechercheLoueur(int IDMembre);
    void deleteObjet(int ID);
    void enprunterObjet(int IDMembre,int IDObjet);
    void rendreObjet(int IDMembre ,int IDObjet);
    void afficheListObjet();
    void afficherObjet(int ID);
    void afficheObjetEmprunter(int IDmembreRechercher);
    void modifierObjet(int ID);
    void saveListe();


    MembreList *Membre = new MembreList; // pas sus faire autrement

    protected:


    int m_objectRechercher;
    int m_IDLus,Ienprunte,m_IDloueurLus;

    std::string nomObjet,nomDuFichier;
    std::string m_titre;
    std::string m_auteur;
    std::string m_genre;
    std::string TMPfichierLus;
    std::string TMPfichier;
    std::string TMPfichierSave;
    std::string chaine1,chaine2,chaine3;
    std::string espace, log;
    std::vector <std::string> ListLivre;
    std::vector <int> IDList,IenpruntList,IDLoueur;
    std::ofstream fluxEcrire;
    std::ofstream fluxSave;
    std::ifstream fluxLire;
    std::ofstream fluxLog;


    private:


};
#endif // OBJET_H



objet.cpp

#include <iostream>
#include <fstream>
#include <string>
#include "objet.h"
#include "menuConsole.h"

using namespace std;

ObjetList::ObjetList()
{

}

ObjetList::ObjetList(string fichier)
{
nomObjet= ("objet");
log ="log.txt";
espace = " ";
fluxLog.open(log.c_str(),ios_base::app);
fluxEcrire.open(fichier.c_str(),ios_base::app);
nomDuFichier = fichier;


}

void ObjetList::LireFichier()
{

    fluxLog<<"lancement de la fonction 'lireLivre'"<<endl;
    ///////////////////////////////////////////
    int taillelistLivre;
    taillelistLivre=ListLivre.size();

    fluxLire.open(nomDuFichier.c_str(),ios::in);


      while(taillelistLivre>=1)
         {
            fluxLog<<"supprime les case des vector"<<endl;
            IDList.resize(0);
            ListLivre.resize(0);
            IenpruntList.resize(0);
            IDLoueur.resize(0);
            taillelistLivre=ListLivre.size();
         }

    while(getline(fluxLire, TMPfichierLus))// compteur
        {
            m_IDLus=0,Ienprunte=0,m_IDloueurLus=0;
            fluxLire>>Ienprunte>>m_IDLus>>chaine1>>chaine2>>chaine3>>m_IDloueurLus;
            TMPfichierLus=espace+chaine1+espace+chaine2+espace+chaine3;
            IDList.push_back(m_IDLus);
            ListLivre.push_back(TMPfichierLus);
            IenpruntList.push_back(Ienprunte);
            IDLoueur.push_back(m_IDloueurLus);
        }
            IDList.pop_back();//je n est pas sus faire autrement sans
            ListLivre.pop_back();
            IenpruntList.pop_back();//quoi il y a une case de trop
            IDLoueur.pop_back();

        fluxLire.close();
        /////////////////////////////////
    fluxLog<<"fin de la fonction 'LireLivre'"<<endl;

}

void ObjetList::ajouteObjet(string titre, string auteur, string genre)
{
    int i(0),newID(0);
    i= IDList.size();// taille du tableau donne une variable a i car la taille est un chiffre
    newID =1+IDList[i];
    fluxLog<<"lancement de la fonction 'ajouteLivre'"<<endl;
    Ienprunte=0;
    fluxEcrire<<Ienprunte<<" "<<newID<<" "<<titre<<" "<<auteur<<" "<<genre<<" "<<"0000"<<endl;
    cout<<"un "<<nomObjet<<"a ete ajouter a la mediatheque avec l'ID"<<newID<<endl;

    fluxLog<<"fin de la fonction 'ajouteLivre'"<<endl;

}

int ObjetList::rechercheObjet(int IDrechercher)
{
fluxLog<<"lancement de la fonction 'rechercheObjet'"<<endl;
    int resultat(0);
    int IDLus;
    int i(0);
   for(i=0;IDLus!=IDrechercher;i++)
        {
        IDLus=IDList[i];

        }
        resultat= 1-i;
        return resultat;
fluxLog<<"fin de la fonction 'rechercheObjet'"<<endl;
}

void ObjetList::deleteObjet(int ID)
{
    fluxLog<<"lancement de la fonction 'deleteLivre'"<<endl;

   int i=0;
   int tmpID;

   int tailleIDlist;
   tailleIDlist=IDList.size();

    ofstream fluxSave(nomDuFichier.c_str(),ios::trunc);
    fluxSave<<"1000//////////// "<<nomObjet<<" //////////////////"<<endl;


  while(i <tailleIDlist)
    {
        tmpID=IDList[i];
        if(tmpID == ID)
        {
        i++;
        cout<<"le "<<nomObjet<<" rechercher a ete trouver et effacer"<<endl;
        }

      else
        {
        fluxSave<<IenpruntList[i]<<espace<<IDList[i]<<espace<<ListLivre[i]<<espace<<IDLoueur[i]<<endl;
        i++;
        }
    }

    fluxSave.close();

    fluxLog<<"fin de la fonction 'deleteLivre'"<<endl;

}

void ObjetList::afficheListObjet()
{
    fluxLog<<"lancement de la fonction 'afficheListLivre'"<<endl;



    int taillelistLivre;
    taillelistLivre= ListLivre.size();

    cout<<"voici la liste des "<<nomObjet<<endl<<" il y a "<<taillelistLivre<<espace<<nomObjet<<endl;;

    for(int i=0; i <taillelistLivre;i++)
    {

        cout<<IDList[i]<<espace<<ListLivre[i]<<endl;
    }

      fluxLog<<"fin de la fonction 'afficheListLivre'"<<endl;
}

void ObjetList::afficherObjet(int ID)
{
    fluxLog<<"lancement de la fonction 'afficheLivre'"<<endl;

    int i(0);
    i= rechercheObjet(ID);
    cout<<"le "<<nomObjet<<" demander est :"<<endl;

    cout<<IDList[i]<<espace<<ListLivre[i]<<endl<<endl<<endl;
    fluxLog<<"fin de la fonction 'afficheLivre'"<<endl;
}

void ObjetList::afficheObjetEmprunter(int IDmembreRechercher)
{
    fluxLog<<"lancement de la fonction 'afficheObjetEmprunter'"<<endl;
    /**recherche dans la liste des objet si l ID du loueur egale a L id demander**/

    int IDLus(0);
    int i(0),j(0);
    int tailleMax = ListLivre.size();
    for(i=0;i<tailleMax;i++)
    {
        IDLus=IDLoueur[i];

        if(IDLus==IDmembreRechercher)
        {
        j++;
        cout<<ListLivre[i]<<" est enprunter par "<<Membre->getMembreLoueur(IDmembreRechercher)<<endl;
        }
    }

    if(j == 0)
    {
       cout<<"cette personne n'a pas louer de "<<nomObjet<<endl;
    }

    fluxLog<<"fin de la fonction 'afficheObjetEmprunter'"<<endl;
}
void ObjetList::modifierObjet(int ID)
{
    fluxLog<<"lancement de la fonction 'modifierLivre'"<<endl;

    int i(0);
    i=rechercheObjet(ID);
    string TmpTitre,TmpAuteur,TmpGenre;



            cout<<endl<<"vous avez choisis de mofichier un "<<nomObjet<<endl;
            cout<<"enter le nom du "<<nomObjet<<endl;
            cin>>TmpTitre;
            cout<<"enter le nom de l auteur du "<<nomObjet<<endl;
            cin>>TmpAuteur;
            cout<<"enter le genre du "<<nomObjet<<endl;
            cin>>TmpGenre;


    ListLivre[i] = TmpTitre+ espace + TmpAuteur + espace + TmpGenre;// dans un tableau des strung


    fluxLog<<"fin de la fonction 'modifierList'"<<endl;
}

void ObjetList::saveListe()
{
    fluxLog<<"lancement de la fonction 'SaveListe'"<<endl;
    int i=0;
    int tailleIDlist;
    tailleIDlist=IDList.size();

    fluxSave.open(nomDuFichier.c_str(),ios::trunc);
    fluxSave<<"0 1000//////////// "<<nomObjet<<" //////////////////"<<endl;


  while(i <tailleIDlist)
    {
        fluxSave<<IenpruntList[i]<<espace<<IDList[i]<<espace<<ListLivre[i]<<espace<<IDLoueur[i]<<endl;
        i++;
    }

    fluxSave.close();
    fluxLog<<"fin de la fonction 'saveListe'"<<endl;
}

void ObjetList::enprunterObjet(int IDMembre,int IDObjet)
{
fluxLog<<"lancement de la fonction 'enprunterObjet'"<<endl;
/** regarde dans la list des objet si enprunter si oui arreter fonction et le dire
 sinon changer l'IenprunterList et et changer l'IDlouer**/

    int i(0);
    string result = Membre->getMembreLoueur(IDMembre);
    i = rechercheObjet(IDObjet);
    cout<<rechercheObjet(IDObjet)<< i<<IenpruntList[i]<<ListLivre[i]<<endl;

    if(IenpruntList[i]==0)
    {
        IenpruntList[i] = 1 ;
        IDLoueur[i] = IDMembre;

        cout<< "ce "<<nomObjet<<" vien d etre enprunter par "<<result<<endl<<endl;
    }
    else(IenpruntList[i]==1);
    {
        cout<<"non cette objet et deja enprunter par"<<IDLoueur[i]<<endl<<endl;
    }


fluxLog<<"fin de la fonction 'enprunterObjet'"<<endl;
}

void ObjetList::rendreObjet(int IDMembre,int IDObjet)
{
fluxLog<<"lancement de la fonction 'rendreObjet'"<<endl;
    int i(0);
    string result =Membre->getMembreLoueur(IDMembre);
    i = rechercheObjet(IDObjet);
    cout<<rechercheObjet(IDObjet)<< i<<IenpruntList[i]<<ListLivre[i]<<endl;

    if(IDLoueur[i]!=IDMembre)
    {
        cout<<"cette personne("<<result<<")n'a pas louer ce"<<nomObjet<<endl;
    }
    if(IDLoueur[i]==IDMembre)
    {
        if(IenpruntList[i]==1)
        {
            IenpruntList[i] = 0 ;
            IDLoueur[i] = 0000;

            cout<< "ce "<<nomObjet<<" vien d etre rendu par "<<result<<endl<<endl;
        }
        else(IenpruntList[i]==0);
        {
            cout<<"non cette objet et n est pas enprunter"<<endl<<endl;
        }
    }

fluxLog<<"fin de la fonction 'rendreObjet'"<<endl;
}



livre.h

#ifndef DEF_LIVRE
#define DEF_LIVRE
#include <iostream>
#include <fstream>
#include <string>
#include <vector>
#include "objet.h"



class LivreList : public ObjetList
{

public:

    LivreList();
    LivreList(std::string fichier);

};



#endif // LIVRE_H

livre.cpp

#include <iostream>
#include <fstream>
#include <cstring>
#include "livre.h"

using namespace std;

LivreList::LivreList() : ObjetList()
{

}
LivreList::LivreList(string fichier) : ObjetList(fichier)
{
nomObjet= ("livre");

fluxLog.open(log.c_str(),ios_base::app);
fluxEcrire.open(fichier.c_str(),ios_base::app);
nomDuFichier = fichier;

}

membre.h

#ifndef DEF_MEMBRE
#define DEF_MEMBRE
#include <iostream>
#include <fstream>
#include <string>
#include <vector>



class MembreList
{
public:

    MembreList();
    void ajouteMembre(std::string nom,std::string prenom);
    void LireFichierMembre();
    std::string afficheMembreLoueur(int IDmenbre);
    void savelisteMembre();



private:

    int IDrechercher,m_IDMembreLus,IDObjetLouer;
    std::string TMPfichierMembreLus,nomObjet,chaine1,chaine2;
    std::vector <std::string> ListMembre;
    std::vector <int> IDListMembre;
    std::ofstream fluxEcrireMembre,fluxLog;
    std::ofstream fluxSaveMembre;
    std::ifstream fluxLireMembre;



};
#endif

membre.cpp

#include <iostream>
#include <fstream>
#include <string>
#include "membre.h"

using namespace std;

MembreList::MembreList()
{
nomObjet= "MembreList";
fluxEcrireMembre.open("data/listmembre.biblio",ios::app);
fluxLog.open("log.txt,ios_base::app");

}

void MembreList::LireFichierMembre()
{

    fluxLog<<"lancement de la fonction 'LireFichierMembre'"<<endl;
    ///////////////////////////////////////////
    int taillelistMembre;
    taillelistMembre=ListMembre.size();

    fluxLireMembre.open("data/listmembre.biblio",ios::in);



      while(taillelistMembre>=1)
         {
            fluxLog<<"supprime les case des vector"<<endl;
            IDListMembre.resize(0);
            ListMembre.resize(0);
            taillelistMembre=ListMembre.size();
         }
   string espace(" ");
    while(getline(fluxLireMembre, TMPfichierMembreLus))// compteur
        {

            fluxLireMembre>>m_IDMembreLus>>chaine1>>chaine2;
            TMPfichierMembreLus=espace+chaine1+espace+chaine2;
            IDListMembre.push_back(m_IDMembreLus);
            ListMembre.push_back(TMPfichierMembreLus);

        }
            IDListMembre.pop_back();//je n est pas sus faire autrement sans
            ListMembre.pop_back();//quoi il y a une case de trop


        fluxLireMembre.close();
        /////////////////////////////////
    fluxLog<<"fin de la fonction 'LireFichierMembre'"<<endl;

}

void MembreList::ajouteMembre(std::string nom,std::string prenom)
{
fluxLog<<"lancement de la fonction 'ajouteMembre'"<<endl;

    int i(0),newID(0);
    i= IDListMembre.size();
    newID =1+IDListMembre[i];
    fluxEcrireMembre<<newID<<" "<<nom<<" "<<prenom<<endl;
    cout<<"un "<<nomObjet<<"a ete ajouter a la mediatheque avec l'ID"<<newID<<endl;
    fluxLog<<"fin de la fonction 'ajouteLivre'"<<endl;


fluxLog<<"fin de la fonction 'ajouteMembre'"<<endl;
}

 string MembreList::getMembreLoueur(int IDmenbre)
{
fluxLog<<"lancement de la fonction 'afficheObjetEmprunter'"<<endl;
string resultat;
    int IDLus;
    int i;
    for(i=0;IDLus!=IDmenbre;i++)
        {
        IDLus=IDListMembre[i];

        }
i--;
resultat = ListMembre[i];
return resultat;


      fluxLog<<"fin de la fonction 'afficheObjetEmprunter'"<<endl;
}

void MembreList::savelisteMembre()
{
fluxLog<<"lancement de la fonction 'SaveListeMembre'"<<endl;

    int tailleIDlistMembre;
    tailleIDlistMembre=IDListMembre.size();

    fluxSaveMembre.open("data/listmembre.biblio",ios::trunc);
    fluxSaveMembre<<"9000//////////// "<<nomObjet<<" //////////////////"<<endl;

int i(0);
    while(i <tailleIDlistMembre)
    {
        fluxSaveMembre<<IDListMembre[i]<<" "<<ListMembre[i]<<" "<<endl;
        i++;
    }

    fluxSaveMembre.close();
    fluxLog<<"fin de la fonction 'saveListe'"<<endl;
}

Voilà comme vous pouvez le voir j'ai un kif personnel j'aime écrire dans un fichier log.txt si une fonction est en cours ou non je même pas sur que ne se servent à grand-chose

Lol dites-moi ce que vous en penser :)


-
Edité par teslas 31 octobre 2013 à 20:27:04

11 novembre 2013 à 16:55:25

[Exercice]

TP ZFraction : Affichage en écriture naturelle

Voici un exercice pouvant venir "compléter" le TP sur ZFraction (ici).

Il s'agit de créer un groupe de fonctions (voire même une seule) permettant d'afficher ceci :

Au lieu de ceci :

85/36 + 4/5 = 569/180
8/13 * 13/2 = 4
4/7 - 1/14 = 1/2
21/8 / 3/2 = 7/4

Voici la fonction main associée :

int main()
{
    prettyCalc(ZFraction(85,36),'+',ZFraction(4,5));
    prettyCalc(ZFraction(8,13),'*',ZFraction(13,2));
    prettyCalc(ZFraction(4,7),'-',ZFraction(1,14));
    prettyCalc(ZFraction(21,8),'/',ZFraction(3,2));
    return 0;
}


Si vous procédez comme moi, vous aurez besoin de ceci :

  • Convertir un int en string :
    #include <sstream>
    
    ostringstream oss; //Déclaration d'un objet de type flux de sortie
    
    int nombre=8;
    oss << nombre; //Cela agit comme cout << nombre, sauf que c'est écrit dans oss
    string chaine=oss.str(); //Le contenu de oss est copié dans chaine : chaine vaut désormais "8"
    
    oss.str(""); //Efface le contenu de oss (ça devrait servir)
     
  • Connaître le nombre de chiffres d'un nombre :
     
    #include <cmath>
    
    int nombre=12345;
    
    int nombreChiffres=int(log10(nombre))+1; //Partie entière du logarithme base 10 de nombre, plus un
    //nombreChiffres vaut désormais 5

Conseil : utilisez 3 chaînes de caractères, une pour chaque ligne.

Bon travail !

(PS: si  quelqu'un me dit où est passée la balise <spoiler>, je mettrai des indices)

22 novembre 2013 à 10:59:51

@zero44 : l'utilisation de std::to_string serait plus maligne, au pire d'une fonction template faisant la même chose.

-
Edité par Ksass`Peuk 22 novembre 2013 à 11:00:20

Posez vos questions ou discutez informatique, sur le Discord NaN | Tuto : Preuve de programmes C
22 novembre 2013 à 11:46:35

Si ça peut aider, voici une implémentation perso de tostring.

tostring.h

/**
 * \file    tostring.h
 * \author  Caduchon
 * \brief   Tools to convert values to the string format
 */
#pragma once
#ifndef _CADUCHON_INCLUDE__TOSTRING_H_
#define _CADUCHON_INCLUDE__TOSTRING_H_

#include <sstream>
#include <iomanip>

/**
 * \def     FLOAT_SCIENTIFIC
 * \brief   Print with scientific mode
 */
#define FLOAT_SCIENTIFIC true
/**
 * \def     FLOAT_NO_SCIENTIFIC
 * \brief   Print with not scientific mode
 */
#define FLOAT_NO_SCIENTIFIC false
/**
 * \def     BOOL_ALPHABETIC
 * \brief   Print boolean values as "true" or "false"
 */
#define BOOL_ALPHABETIC true
/**
 * \def     BOOL_NUMERIC
 * \brief   Print boolean values as "1" or "0"
 */
#define BOOL_NUMERIC false

#define DEFAULT_BOOL_ALPHA BOOL_ALPHABETIC
#define DEFAULT_FLOAT_PRECISION 6
#define DEFAULT_FLOAT_SCIENTIFIC FLOAT_NO_SCIENTIFIC
#define DEFAULT_DOUBLE_PRECISION 14
#define DEFAULT_DOUBLE_SCIENTIFIC FLOAT_NO_SCIENTIFIC

namespace caduchon
{
  
  /**
   * \brief  Convert the value to the string format
   * \attention  The template type T must implement \code std::ostream& operator<<(std::ostream&,const T&) \endcode
   */
  template <typename T>
  std::string tostring(const T& value);
  
  /** \brief Convert any boolean value to the string format */
  template <>
  std::string tostring<bool>(const bool& value);
  
  /** \brief Convert any float value to the string format */
  template <>
  std::string tostring<float>(const float& value);
  
  /** \brief Convert any double value to the string format */
  template <>
  std::string tostring<double>(const double& value);
  
  /**
   * \brief  Convert integer values to the string format
   * \param value  The value to be converted to string
   * \param width  The fixed length of the string
   * \param fill   Symbol used to fill the string when it's needed
   */
  template <typename T>
  std::string tostring(const T& value, unsigned short int width, char fill);
  
  /**
   * \brief  Convert real values to the string format
   * \param value       The value to be converted to string
   * \param scientific  If true, the scientific mode is used (use FLOAT_SCIENTIFIC or FLOAT_NO_SCIENTIFIC)
   * \param precision   Precision of the number
   * \param width       The fixed length of the string
   * \param fill        Symbol used to fill the string when it's needed
   */
  template <typename T>
  std::string tostring(const T& value, bool scientific, unsigned short int precision, unsigned short int width, char fill);
  
  /**
   * \brief  Convert boolean values to the string format
   * \param value       The value to be converted to string
   * \param alphabetic  If true, the alphabetic version is used
   */
  std::string tostring(bool value, bool alphabetic);
  
  
  // ------------------------------------
  // ---------- Implementation ----------
  // ------------------------------------
  
  
  /** \author Caduchon */
  template <typename T>
  std::string tostring(const T& value)
  {
    std::ostringstream oss;
    oss << value;
    return oss.str();
  }
  
  /** \author Caduchon */
  template <typename T>
  std::string tostring(const T& value, unsigned short int width, char fill)
  {
    std::ostringstream oss;
    oss << std::setfill(fill) << std::setw(width) << value;
    return oss.str();
  }
  
  /** \author Caduchon */
  template <typename T>
  std::string tostring(const T& value, bool scientific, unsigned short int precision, unsigned short int width, char fill)
  {
    std::ostringstream oss;
    oss << (scientific ? std::scientific : std::fixed) << std::setprecision(precision);
    if(width > 0)
      oss << std::setfill(fill) << std::setw(width);
    oss << (value == 0.0 ? 0.0 : value);
    return oss.str();
  }
  
}

#endif

tostring.cpp

/**
 * \file    tostring.cpp
 * \author  Caduchon
 * \brief   Implementation of some tools for string convertion
 */
#include "tostring.h"

namespace caduchon
{
  
  /** \author Caduchon */
  template <>
  std::string tostring<bool>(const bool& value)
  {
    std::ostringstream oss;
    oss << (DEFAULT_BOOL_ALPHA ? std::boolalpha : std::noboolalpha) << value;
    return oss.str();
  }
  
  /** \author Caduchon */
  template <>
  std::string tostring<float>(const float& value)
  {
    std::ostringstream oss;
    if(DEFAULT_FLOAT_SCIENTIFIC)
      oss << std::scientific << std::setprecision(DEFAULT_FLOAT_PRECISION) << (value == 0.0 ? 0.0 : value);
    else
      oss << std::setprecision(DEFAULT_FLOAT_PRECISION + 1) << (value == 0.0 ? 0.0 : value);
    std::string str = oss.str();
    if(str.find('.') == str.npos)
    {
      if((str.at(0) == '-' && str.at(1) >= '0' && str.at(1) <= '9') || (str.at(0) >= '0' && str.at(0) <= '9'))
      {
        if(str.find('e') != str.npos)
          str.insert(str.find('e'), std::string(".0"));
        else
          str = str + std::string(".0");
      }
    }
    return str;
  }
  
  /** \author Caduchon */
  template <>
  std::string tostring<double>(const double& value)
  {
    std::ostringstream oss;
    if(DEFAULT_DOUBLE_SCIENTIFIC)
      oss << std::scientific << std::setprecision(DEFAULT_DOUBLE_PRECISION) << (value == 0.0 ? 0.0 : value);
    else
      oss << std::setprecision(DEFAULT_DOUBLE_PRECISION + 1) << (value == 0.0 ? 0.0 : value);
    std::string str = oss.str();
    if(str.find('.') == str.npos)
    {
      if((str.at(0) == '-' && str.at(1) >= '0' && str.at(1) <= '9') || (str.at(0) >= '0' && str.at(0) <= '9'))
      {
        if(str.find('e') != str.npos)
          str.insert(str.find('e'), std::string(".0"));
        else
          str = str + std::string(".0");
      }
    }
    return str;
  }
  
  /** \author Caduchon */
  std::string tostring(bool value, bool alphabetic)
  {
    std::ostringstream oss;
    oss << (alphabetic ? std::boolalpha : std::noboolalpha) << value;
    return oss.str();
  }
  
}



Je ne suis responsable que de ce que je dis, pas de ce que vous comprenez... - /!\ Négligences de sécurité sur OpenClassrooms /!\
19 janvier 2014 à 11:34:41

bonjour tous le monde j'ai un exercice ,si vous pouvez lui trouver une solution!????????
12 février 2014 à 14:31:48

Bonjour à tous, j'ai fait l'exercice Biblio++ jusqu’au niveau 5 (je n'ai pas utilisé le système de Dewey, juste 1, 2, 3,....). Je voudrais donc avoir un avis sur mon code (il est assez long), il manque quelque truc mais il est opérationnel. Voici un lien pour le telecharger : ici (projet code::blocks). Merci à tous. :)

When you got nothing, you got nothing to lose.
1 mars 2014 à 12:14:12

Au cours de mes lectures diverses sur le C++, j'ai pensé à un petit exercice facile (ou pas, j'ai du mal à évaluer la difficulté). L'énoncé est simple :

Que retourne cette fonction ? (identifier tous les cas possibles selon les valeurs passées en arguments)

int set_and_add_values(int* a, int* b) {
    *a = 1;
    *b = 2;
    return (*a + *b);
}

(laissez un peu les gens réfléchir, ne donnez pas tout de suite la réponse si vous la connaissez)

Pour poser des questions ou simplement discuter informatique, vous pouvez rejoindre le discord NaN.
2 mars 2014 à 15:02:40

Aucune réponse :( mon problème est trop simple ?

Un complément (au cas où) :

J'appelle fonction précédente dans un test unitaire, pour vérifier qu'elle fonctionne correctement :

void foo(int* a, int* b) {
    int value = set_and_add_values(a, b);
    assert(value == 3);
}

Ce code déclenche une erreur "Assertion `value == 3' failed."

Pourquoi ?

Pour poser des questions ou simplement discuter informatique, vous pouvez rejoindre le discord NaN.
2 mars 2014 à 15:29:01

bah ecoute le problème vient surtout du faite que

  • Tu demandes a ce qu'on ne réponde pas pour que les autres cherche :p
  • Sa n'est pas un exercice de codage, sa n'est qu'une question, c'est beaucoup moins intéressant qu'un exercice ou les participants doivent coder quelque chose ;)

[Exercices] Venez vous entraîner !

× Après avoir cliqué sur "Répondre" vous serez invité à vous connecter pour que votre message soit publié.
  • Editeur
  • Markdown