Inclure headline dans l'IDE

williamlls · March 14, 2021, 12:42am

Bonjour à tous,

Je me suis récemment lancé dans un projet. Ayant appris les bases en C++ en cours cette années et l'Arduino de mon côté, j'ai voulu "mixer" les deux dans un but ludique.

Mon projet est le suivant :
J'ai créé sous Visual Studio un programme permettant de gérer l'attribution des tâches ménagères. Pour ce faire j'ai créé 4 classes :
Cindividu : Représentant les individus de la maison
CHome : Représentant la maison
CRoom : Représentant les pièces de la maison
CTask : Représentant les tâches ménagères.

Mon code source semble bien fonctionner et attribue correctement les tâches ménagère de la journée à un individu.

Mon but à terme est d'afficher les tâches de la journée sur un écran 16*2.
Il y aura 2 boutons à côté :
Le premier dit au programme que la tâche a été accomplie et l'attribue donc à l'individu suivant.
Le second permet d'afficher les autres tâches une par une (Lié en manque de place de l'afficheur).

J'ai placé mes fichiers .h et .cpp dans un fichier "Home" lui même dans le fichier librairies d'Arduino.

Lorsque que je les inclue :
#include<CHome.h>
#include<CTask.h>
#include<CRoom.h>
#include<CHome.cpp>
#include<CRoom.cpp>
#include<CTask.cpp>
l'IDE semble les trouver.

Cependant j'ai un message d'erreur concernant les destructeurs de mes classes.

In file included from C:\Users\lalis\AppData\Local\Temp\arduino_modified_sketch_197725\sketch_mar14a.ino:5:0:
C:\Users\lalis\OneDrive\Documents\Arduino\libraries\Home/CHome.cpp: In destructor 'CHome::~CHome()':
C:\Users\lalis\OneDrive\Documents\Arduino\libraries\Home/CHome.cpp:28:16: error: no matching function for call to 'CHome::CRoom()'
  CRoom::~CRoom();
                ^
In file included from C:\Users\lalis\OneDrive\Documents\Arduino\libraries\Home/CHome.h:2:0,
                 from C:\Users\lalis\AppData\Local\Temp\arduino_modified_sketch_197725\sketch_mar14a.ino:2:
C:\Users\lalis\OneDrive\Documents\Arduino\libraries\Home/CRoom.h:16:5: note: candidate: CRoom::~CRoom()
     ~CRoom();
     ^
C:\Users\lalis\OneDrive\Documents\Arduino\libraries\Home/CRoom.h:16:5: note:   candidate expects 1 argument, 0 provided
In file included from C:\Users\lalis\AppData\Local\Temp\arduino_modified_sketch_197725\sketch_mar14a.ino:6:0:
C:\Users\lalis\OneDrive\Documents\Arduino\libraries\Home/CRoom.cpp: In destructor 'CRoom::~CRoom()':
C:\Users\lalis\OneDrive\Documents\Arduino\libraries\Home/CRoom.cpp:14:16: error: no matching function for call to 'CRoom::CTask()'
  CTask::~CTask();
                ^
In file included from C:\Users\lalis\OneDrive\Documents\Arduino\libraries\Home/CRoom.h:2:0,
                 from C:\Users\lalis\OneDrive\Documents\Arduino\libraries\Home/CHome.h:2,
                 from C:\Users\lalis\AppData\Local\Temp\arduino_modified_sketch_197725\sketch_mar14a.ino:2:
C:\Users\lalis\OneDrive\Documents\Arduino\libraries\Home/CTask.h:19:2: note: candidate: CTask::~CTask()
  ~CTask();
  ^
C:\Users\lalis\OneDrive\Documents\Arduino\libraries\Home/CTask.h:19:2: note:   candidate expects 1 argument, 0 provided
Utilisation de la bibliothèque Home prise dans le dossier : C:\Users\lalis\OneDrive\Documents\Arduino\libraries\Home (legacy)
exit status 1
Erreur de compilation pour la carte Arduino Uno

Ai-je fais fausse route en pensant qu'il était possible de créer son programme C++ à côté et de l'importer dans l'IDE Arduino ?

Auriez vous des conseils pour mener à bien mon projet ?

Je précise également que je suis encore débutant dans ce domaine
Merci d'avance

lesept · March 14, 2021, 12:56am

Tu peux très bien créer une bibliothèque et la mettre dans un répertoire contenant les fichiers .h et .cpp, lui-même dans le répertoire libraries de ton dossier arduino.
Un programme arduino se compose d'une fonction setup et d'une fonction loop, avec toutes les autres fonctions que tu veux faire en plus. C'est le format standard, mais je crois qu'il est possible de faire un code C++ habituel avec un main (pas sûr cependant).
Ton problème doit venir du code de tes bibliothèques, et n'est peut-être pas lié au format Arduino.
Poste un exemple de couple de fichier .h et .cpp qui posent problème, on verra s'ils contiennent une erreur.

williamlls · March 14, 2021, 1:06am

Voici ma classe CTask

#pragma once
#include<iostream>
using namespace std;
#include"CIndividu.h"

// ------ ------ Classe définissant les tâches ------ ------

class CTask : public CIndividu
{
protected:
	string m_Tname;
	int m_time;
	int m_difficulty;
	int m_nbday;
	int* m_pday;
	CIndividu m_Individu;

public:
	CTask();
	CTask(string name, int time, int difficulty, int nbday, int* day);
	~CTask();

	void SetData(string name, int time, int difficulty,int nbday, int* day);
	void Affiche();
	int Val();
	int Rec();
	int Day(int);
	void Individu(CIndividu);		//Attribue un Individu à la tâche
	string sDay(int);
	CTask operator = (CTask const&);
	CIndividu indiv();
	bool operator==(CTask&);
};

#include "CTask.h"

CTask::CTask() : m_Tname(""), m_time(0),m_difficulty(0),m_nbday(0),m_pday(NULL)
{
}

CTask::CTask(string name, int time, int difficulty, int nbday, int* day)
{
	m_pday = new int[m_nbday];
	m_Tname = name;
	m_time = time;
	m_difficulty = difficulty;
	m_nbday = nbday;
	m_pday = new int[m_nbday];
	for (int i = 0; i < m_nbday; i++)
	{
		m_pday[i] = day[i];
	}
}

CTask::~CTask()
{
}

void CTask::SetData(string name, int time, int difficulty,int nbday, int* day)
{
	m_Tname = name;
	m_time = time;
	m_difficulty = difficulty;
	m_nbday = nbday;
	m_pday = new int[m_nbday];
	for (int i = 0; i < m_nbday; i++)
	{
		m_pday[i] = day[i];
	}
}

void CTask::Affiche()
{
	cout << m_Tname << endl;
	m_Individu.Affiche();
	//cout << m_time << endl;
	//cout << m_difficulty << endl;
	//cout << m_nbday << endl;
	/*for (int i = 0; i < m_nbday - 1; i++)
	{
		cout << m_pday[i] << " ";
	}
	cout << m_pday[m_nbday - 1];*/
	cout << endl;
}

int CTask::Val()
{
	switch (m_difficulty)
	{
	case 1:
		return m_time;
	case 2:
		return m_time + 5;
	case 3:
		return m_time + 10;
	default:
		return -1;
	}
}

int CTask::Rec()
{
	return m_nbday;
}

int CTask::Day(int i)
{
	return m_pday[i];
}

void CTask::Individu(CIndividu I)
{
	m_Individu.Copie(I);
}

string CTask::sDay(int jour)
{
	switch (jour)
	{
	case 1:
		return"Lundi";
	case 2:
		return"Mardi";
	case 3:
		return"Mercredi";
	case 4:
		return"Jeudi";
	case 5:
		return"Vendredi";
	case 6:
		return"Samedi";
	case 7:
		return"Dimanche";
	case 8:
		return"Lundi";
	case 9:
		return"Mardi";
	case 10:
		return"Mercredi";
	case 11:
		return"Jeudi";
	case 12:
		return"Vendredi";
	case 13:
		return"Samedi";
	case 14:
		return"Dimanche";
	default:
		return"Not a day";
	}
}

CTask CTask::operator=(CTask const& T)
{
	m_Tname = T.m_Tname;
	m_time = T.m_time;
	m_difficulty = T.m_difficulty;
	m_nbday = T.m_nbday;
	m_pday = new int[m_nbday];
	for (int i = 0; i < m_nbday; i++)
	{
		m_pday[i] = T.m_pday[i];
	}
	m_Individu.Copie(T.m_Individu);
	return *this;
}

CIndividu CTask::indiv()
{
	return m_Individu;
}

bool CTask::operator==(CTask& T)
{
	if (m_Tname == T.m_Tname)
	{
		return true;
	}
	else 
	{
		return false;
	}
}

J'ai modifié également certains points avant de l'inclure dans la bibliothèque :
J'ai retiré toutes les fonctions Affiche ainsi que iostream qui semblait posé problème.
Il y a des fonctions que j'ai créé surtout pour tester mon code dans le main.

williamlls · March 14, 2021, 1:16am

Tant qu'à faire je vais fournir tout mon code, ça simplifiera peut être la recherche d'erreur

Classe CIndividu :

#pragma once
#include<iostream>
#include<string>
using namespace std;

class CIndividu 
{
protected:
    string m_name;

public:
    CIndividu();
    CIndividu(string);
    ~CIndividu();

    void Copie(CIndividu);
    void SetIndiv(string);
    void Affiche();
    string Name();
    bool operator==(CIndividu&);
};

#include "CIndividu.h"

CIndividu::CIndividu() : m_name("")
{
}

CIndividu::CIndividu(string name)
{
	m_name = name;
}

CIndividu::~CIndividu()
{
}


void CIndividu::Copie(CIndividu I)
{
	m_name = I.m_name;
}

void CIndividu::SetIndiv(string name)
{
	m_name = name;
}

void CIndividu::Affiche()
{
	cout << m_name << endl;
}

string CIndividu::Name()
{
	return m_name;
}

bool CIndividu::operator==(CIndividu& I)
{
	if (m_name == I.m_name)
	{
		return true;
	}
	else
	{
		return false;
	}
}

Classe CHome :

#pragma once
#include "CRoom.h"
#include"CIndividu.h"

// ------ ------ Classe définissant la maison ------ ------

class CHome :
    public CRoom,public CIndividu
{
protected:
    int m_nbroom;       //Nombre de pièce
    CRoom* m_proom;     //Liste des pièces
    int m_nbtask;       //Nombre total de tâche
    CTask* m_ptask;     //Liste totale de tâche
    int m_nbtaskday;    //Nombre de tâche le jour j
    CTask* m_ptaskday;  //Liste des tâches du jour j
    int m_nbIndiv;      //Nombre d'individu
    CIndividu* m_pIndiv;   //Liste des individus

public:
    CHome();
    ~CHome();

    void SetData(int Nbroom, CRoom* R);
    void AfficheAll(); 
    void AfficheTask();
    void AfficheTask(int jour);
    void Add(CRoom*);   // Ajoute toutes les tâches dans la liste de tâche
    int Nbroom();
    int Nbtask();
    void Tri();
    void TaskDay(int);  // Remplie la liste des tâches du jour
    void Permute(int i, int j);
    void SetIndiv(int nbIndiv, CIndividu* pIndiv);
    void AddGlobalTask(CTask);
    void AttribTask();  // Attribue les Individus aux tâches
    void AfficheIndiv();
    void Done(CTask);   // Passe à l'individu suivant dans la liste (Doit être remplacer dans les deux listes principale m_ptask et m_ptaskday
    int IndiceIndiv(CTask); // Retourne l'indice de l'individu concerné par cette tâche
    int IndiceTask(CTask);  // Retourne l'indice de la tâche entrée en paramètre
    void Echange(CTask,int);
    void AfficheIndiv(CTask);
};

#include "CHome.h"

CHome::CHome() : m_nbroom(0), m_proom(NULL),m_nbtask(0),m_ptask(NULL),m_nbtaskday(0),m_ptaskday(NULL), m_nbIndiv(0),m_pIndiv(NULL)
{}

CHome::~CHome()
{
	if (m_ptask != NULL)
	{
		delete[] m_ptask;
		m_ptask = NULL;
	}
	if (m_proom != NULL)
	{
		delete[] m_proom;
		m_proom = NULL;
	}
	if (m_ptaskday != NULL)
	{
		delete[] m_ptaskday;
		m_ptaskday = NULL;
	}
	if (m_pIndiv != NULL)
	{
		delete[] m_pIndiv;
		m_pIndiv = NULL;
	}
	CRoom::~CRoom();
}

void CHome::SetData(int Nbroom, CRoom* R)
{
	m_nbroom = Nbroom;
	
	m_proom = new CRoom[m_nbroom];
	m_ptask = new CTask[m_nbtask];
	int k = 0;
	for (int i = 0; i < m_nbroom; i++)
	{
		m_proom[i].Copie(R[i]);
	}
	Add(R);
}

void CHome::AfficheAll()
{
	cout << "My Home" << endl << endl;
	for (int i = 0; i < m_nbroom; i++)
	{
		m_proom[i].Affiche();
	}
}

void CHome::AfficheTask()
{
	cout << "Liste tache complete : " << endl;
	for (int j = 0; j < m_nbtask; j++)
	{
		m_ptask[j].Affiche();
	}
}

void CHome::AfficheTask(int jour)
{
	cout << "Liste tache de " << sDay(jour) << endl;
	TaskDay(jour);
	for (int j = 0; j < m_nbtaskday; j++)
	{
		m_ptaskday[j].Affiche();
	}
}

void CHome::Add(CRoom* R)
{
	
	int nbtask = 0;
	for (int i = 0; i < m_nbroom; i++)
	{
		nbtask += R[i].NbTask();
	}
	m_nbtask = nbtask;
	m_ptask = new CTask[m_nbtask];
	int i = 0;
	while (i < m_nbtask)
	{
		for (int j = 0; j < m_nbroom; j++)
		{
			for (int k = 0; k < R[j].NbTask(); k++)
			{
				m_ptask[i] = R[j].Task(k);
				i++;
			}
		}
	}
}

int CHome::Nbroom()
{
	return m_nbroom;
}

int CHome::Nbtask()
{
	return m_nbtask;
}

void CHome::Tri()
{
	for (int i = 0; i < m_nbtask; i++)
	{
		for (int j = i; j < m_nbtask; j++)
		{
			if (m_ptask[i].Val() > m_ptask[j].Val())
			{
				Permute(i, j);
			}
		}
	}
}

void CHome::TaskDay(int jour)
{
	m_nbtaskday = 0;
	for (int i = 0; i < m_nbtask; i++)
	{
		for (int j = 0; j < m_ptask[i].Rec(); j++)
		{
			if (m_ptask[i].Day(j) == jour)
			{
				m_nbtaskday += 1;
			}
		}
	}
	int k = 0;
	if (m_ptaskday != NULL)
	{
		delete[] m_ptaskday;
	}
	m_ptaskday = new CTask[m_nbtaskday];
	for (int i = 0; i < m_nbtask; i++)
	{
		for (int j = 0; j < m_ptask[i].Rec(); j++)
		{
			if (m_ptask[i].Day(j) == jour)
			{
				m_ptaskday[k] = m_ptask[i];
				k++;
			}
		}
	}
}

void CHome::Permute(int i, int j)
{
	CTask T = m_ptask[i];
	m_ptask[i] = m_ptask[j];
	m_ptask[j] = T;
}

void CHome::SetIndiv(int nbIndiv, CIndividu* pIndiv)
{
	m_nbIndiv = nbIndiv;
	m_pIndiv = new CIndividu[m_nbIndiv];
	for (int i = 0; i < m_nbIndiv; i++)
	{
		m_pIndiv[i] = pIndiv[i];
	}
}

void CHome::AddGlobalTask(CTask T)
{
	if (m_ptask != NULL)
	{
		CTask* Copie;
		m_nbtask += 1;
		Copie = new CTask[m_nbtask];
		for (int i = 0; i < m_nbtask-1; i++)
		{
			Copie[i] = m_ptask[i];
		}
		Copie[m_nbtask-1] = T;
		delete[] m_ptask;
		m_ptask = new CTask[m_nbtask];
		for (int i = 0; i < m_nbtask; i++)
		{
			m_ptask[i] = Copie[i];
		}
	}
}

void CHome::AttribTask() 
{
	int j = 0;
	for (int i = 0; i < m_nbtask; i++)
	{
		if (j == m_nbIndiv)
		{
			j = 0;
		}
		m_ptask[i].Individu(m_pIndiv[j]);
		j++;
	}
}

void CHome::AfficheIndiv()
{
	for (int i = 0; i < m_nbIndiv; i++)
	{
		m_pIndiv[i].Affiche();
	}
}

void CHome::Done(CTask T)
{
	// Il me faut aussi l'indice de cette tâche en plus de l'indice de l'individu
	int indI = IndiceIndiv(T);
	int indT = IndiceTask(T);
	if (IndiceIndiv(T) == m_nbIndiv - 1)
	{
		T.Individu(m_pIndiv[0]);
	}
	else
	{
		T.Individu(m_pIndiv[IndiceIndiv(T) + 1]);
	}
	Echange(T, indT);
	// Il faut remplacer l'ancienne tâche par la nouvelle
	// Il me faut donc bien l'indice de cette tâche dans la liste (Normalement chaque tâche est unique) On ne peut donc pas les confondre
}

int CHome::IndiceIndiv(CTask T)
{
	for (int i = 0; i < m_nbtask; i++)
	{
		if (m_ptask[i] == T)
		{
			for (int j = 0; j < m_nbIndiv; j++)
			{
				if (m_ptask[i].indiv() == m_pIndiv[j])
				{
					return j;
				}
			}
		}
	}
	return -1;
}

int CHome::IndiceTask(CTask T)
{
	for (int i = 0; i < m_nbtask; i++)
	{
		if (T == m_ptask[i])
		{
			return i;
		}
	}
	return -1;
}

void CHome::Echange(CTask T,int i)
{
	m_ptask[i] = T;
}

void CHome::AfficheIndiv(CTask T)
{
	int ind = IndiceTask(T);
	m_ptask[ind].Affiche();

}

Classe CRoom

#pragma once
#include "CTask.h"

// ------ ------ Classe définissant les pièces ------ ------

class CRoom :
    public CTask
{
protected:
    string m_Rname;
    int m_nbRtask;
    CTask* m_pRtask;

public:
    CRoom();
    ~CRoom();
    
    void SetData(string name, int Nb, CTask* ptask);
    void Affiche();
    void Copie(CRoom&);
    int NbTask();
    CTask Task(int i);
};

#include "CRoom.h"

CRoom::CRoom() : m_Rname(""), m_nbRtask(0), m_pRtask(NULL), CTask()
{
}

CRoom::~CRoom()
{
	if (m_pRtask != NULL)
	{
		delete[] m_pRtask;
		m_pRtask = NULL;
	}
	CTask::~CTask();
}

void CRoom::SetData(string name, int Nb, CTask* ptask)
{
	m_Rname = name;
	m_nbRtask = Nb;
	m_pRtask = new CTask[m_nbRtask];
	for (int i = 0; i < m_nbRtask; i++)
	{
		m_pRtask[i] = ptask[i];
	}
}

void CRoom::Affiche()
{
	cout << m_Rname << endl;
	cout << m_nbRtask << endl;
	for (int i = 0; i < m_nbRtask; i++)
	{
		m_pRtask[i].Affiche();
	}
	cout << endl;
}

void CRoom::Copie(CRoom& R)
{
	m_Rname = R.m_Rname;
	m_nbRtask = R.m_nbRtask;
	m_pRtask = new CTask[m_nbRtask];
	for (int i = 0; i < m_nbRtask; i++)
	{
		m_pRtask[i] = R.m_pRtask[i];
	}
}

int CRoom::NbTask()
{
	return m_nbRtask;
}

CTask CRoom::Task(int i)
{
	return m_pRtask[i];
}

Là encore il y a les fonctions liées à iostream que j'ai supprimé.

biggil · March 14, 2021, 6:55am

la conception de ta classe cTask est problématique:

class CTask : public CIndividu
{
protected:
	.../...
	CIndividu m_Individu;

1 - dire que Ctask dérive de CIndividu signifie que chaque CTask est un CIndividu (puisque une CTask hérite de toutes les propriétés d'un CIndividu). Pas vraimebt évident a-priori !
2 - en plus, la CTask possède un membre de type CIndividu.
Donc, dans chaque CTask, il y a DEUX CIndividus : l'objet CTask qui en est un (voir 1-) plus celui qu'il possède.

Joli sac de noeuds...

JiPe38 · March 14, 2021, 8:57am

Je plussoie, un individu n'est pas une tache ni l'inverse. Dans cet exemple, la maison peut avoir plusieurs pièces, héberger plusieurs personnes, une personne peut se voir affecter plusieurs taches, une tache peut être accomplie dans plusieurs pièces... Tout cela est dynamique. Le mieux pour gérer toutes ces correspondances est d'utiliser des listes génériques. par exemple dans la maison déclarer :

rooms = new List () ;
cuisine = new Room ("Cuisine") ;
.../...
chambre3 new Room ("Chambre 3") ;
rooms->add (cuisine) ;
.../...
rooms->add (salon) ;

Faire la même chose pour les différentes affectations statiques

Pour le dynamique, si Alice doit remplacer Bob pour la vaisselle :

tachesMenageres->remove (Alice) ;
tachesMenageres->remove (Bob) ;
tachesMenageres->vaisselle = Alice ;

Et toc pour la journée de la femme !

hbachetti · March 14, 2021, 11:15am

Gros mélange entre héritage et agrégation/association.

Ces notions doivent être parfaitement comprises avant de se lancer en C++ ou n'importe quel langage OO.

Une pièce ou une tâche est-elle un individu ? non -> pas d'héritage.
Une maison est-elle une pièce ? non -> pas d'héritage
Une maison contient-elle plusieurs pièces ? oui -> agrégation
Une tâche peut-elle être exécutée dans une pièce ? oui -> association
Une tâche peut-elle être exécutée par un individu ? oui -> association

williamlls · March 15, 2021, 8:24pm

Bonsoir,

Tout d'abord merci à tous de m'avoir répondu.
J'ai essayé de me renseigné sur les listes génériques mais je n'ai pas encore bien compris.
J'ai cependant réécris mon code en essayant de tenir compte de vos indications, je n'arrive cependant toujours pas à l'inclure dans l'IDE Arduino.
J'ai supprimé dans mon code la classe string et transformé les "string" en "String" pour l'IDE.

Voici mon nouveau code :

CHome :

#pragma once
#include"CRoom.h"
class CHome
{
protected:
	int m_Nroom;
	CRoom* m_proom;
	int m_Ntask;
	CTask* m_ptask;
	int m_Nindividu;
	CIndividu* m_pindividu;

public:
	CHome();
	~CHome();

	void SetData(int nbroom, CRoom* proom,int ,CIndividu*);
	void AddTask(CTask const&);
	
	// Utilisé dans SetData
	void SetIndividu(int nbindividu, CIndividu* pindividu);
	void Task();	// Assigne les tâches des Room dans Ptask
	void Tri();		// Tri les tâches pour l'attribution 
	void Permute(int i, int j);		// Permute les tâches i et j de la liste 
	void Attrib();	// Attribution des tâches aux individus 
};

#include "CHome.h"

CHome::CHome() : m_Nroom(0),m_proom(NULL),m_ptask(NULL),m_Ntask(0),m_Nindividu(0),m_pindividu(NULL)
{
}

CHome::~CHome()
{
	if (m_proom != NULL)
	{
		delete[] m_proom;
		m_proom = NULL;
	}
	if (m_ptask != NULL)
	{
		delete[] m_ptask;
		m_ptask = NULL;
	}
	if (m_pindividu != NULL)
	{
		delete[] m_pindividu;
		m_pindividu = NULL;
	}
}

void CHome::SetData(int nbroom, CRoom* proom,int nbindividu, CIndividu* pindividu)
{
	m_Nroom = nbroom;
	m_proom = new CRoom[m_Nroom];
	for (int i = 0; i < m_Nroom; i++)
	{
		m_proom[i].Copie(proom[i]);
	}
	SetIndividu(nbindividu, pindividu);
	Task();										// Assigne les tâches des Rooms dans pTask
	Tri();										// Tri les tâches de pTask
	Attrib();									// Attribue un individu à châque tâche
}

void CHome::AddTask(CTask const& Task)
{
	CTask* T;
	T = new CTask[m_Ntask];
	for (int i = 0; i < m_Ntask; i++)
	{
		T[i].Copie(m_ptask[i]);
	}
	m_Ntask += 1;
	m_ptask = new CTask[m_Ntask];
	for (int i = 0; i < m_Ntask-1; i++)
	{
		m_ptask[i].Copie(T[i]);
	}
	m_ptask[m_Ntask - 1].Copie(Task);
	Tri();
}

void CHome::SetIndividu(int nbindividu, CIndividu* pindividu)
{
	m_Nindividu = nbindividu;
	m_pindividu = new CIndividu[m_Nindividu];
	for (int i = 0; i < m_Nindividu; i++)
	{
		m_pindividu[i] = pindividu[i];
	}
}

void CHome::Task()
{
	m_Ntask = 0;
	for (int n = 0; n < m_Nroom; n++)
	{
		m_Ntask += m_proom[n].NTask();
	}
	m_ptask = new CTask[m_Ntask];
	int k = 0;
	for (int i = 0; i < m_Nroom; i++)
	{
		for (int j = 0; j < m_proom[i].NTask(); j++)
		{
			m_ptask[k].Copie(m_proom[i].Task(j));
			k++;
		}
	}
}

void CHome::Tri()
{
	for (int i = 0; i < m_Ntask; i++)
	{
		for (int j = i; j < m_Ntask; j++)
		{
			if (m_ptask[i].Val() > m_ptask[j].Val())
			{
				Permute(i, j);
			}
		}
	}
}

void CHome::Permute(int i, int j)
{
	CTask task(m_ptask[i]);
	m_ptask[i] = m_ptask[j];
	m_ptask[j] = task;
}

void CHome::Attrib()
{
	for (int i = 0; i < m_Ntask; i++)
	{
		int j = 0;
		while(j < m_Nindividu)
		{
			m_ptask[i].Assign(m_pindividu[j]);
			j++;
		}
	}
}

CRoom

#pragma once
#include"CTask.h"

class CRoom
{
protected:
	String m_name;
	int m_Ntask;
	CTask* m_ptask;

public:
	CRoom();
	CRoom(String name, int nbtask, CTask* ptask);
	~CRoom();

	void Copie(CRoom const&);
	int NTask();
	CTask Task(int i);
};

#include "CRoom.h"

CRoom::CRoom() : m_name(""),m_Ntask(0),m_ptask(NULL)
{
}

CRoom::CRoom(String name, int nbtask, CTask* ptask)
{
	m_name = name;
	m_Ntask = nbtask;
	m_ptask = new CTask[m_Ntask];
	for (int i = 0; i < m_Ntask; i++)
	{
		m_ptask[i] = ptask[i];
	}
}

CRoom::~CRoom()
{
	if (m_ptask != NULL)
	{
		delete[] m_ptask;
		m_ptask = NULL;
	}
}

void CRoom::Copie(CRoom const& R)
{
	m_name = R.m_name;
	m_Ntask = R.m_Ntask;
	m_ptask = new CTask[m_Ntask];
	for (int i = 0; i < m_Ntask; i++)
	{
		m_ptask[i].Copie(R.m_ptask[i]);
	}
}

int CRoom::NTask()
{
	return m_Ntask;
}

CTask CRoom::Task(int i)
{
	return m_ptask[i];
}

CTask

#pragma once
#include"CIndividu.h"

class CTask
{
protected:
	String m_name;
	CIndividu m_individu;
	int m_difficulty;
	int m_time;

public:
	CTask();
	CTask(String name, int time, int diff);
	CTask(CTask const&);
	~CTask();

	void Copie(CTask const&);
	int Val();
	void Assign(CIndividu const&);
};

#include "CTask.h"

CTask::CTask() : m_name(""), m_individu(),m_difficulty(0),m_time(0)
{
}

CTask::CTask(String name, int time, int diff)
{
	m_name = name;
	m_time = time;
	m_difficulty = diff;
}

CTask::CTask(CTask const& T)
{
	m_name = T.m_name;
	m_individu.Copie(T.m_individu);
	m_difficulty = T.m_difficulty;
	m_time = T.m_time;
}

CTask::~CTask()
{
}

void CTask::Copie(CTask const& T)
{
	m_name = T.m_name;
	m_individu.Copie(T.m_individu);
	m_difficulty = T.m_difficulty;
	m_time = T.m_time;
}

int CTask::Val()
{
	switch (m_difficulty)
	{
	case 1:
		return m_time;
	case 2:
		return m_time + 5;
	case 3:
		return m_time + 10;
	default:
		return -1;
	}
}

void CTask::Assign(CIndividu const& I)
{
	m_individu.Copie(I);
}

CIndividu

#pragma once


class CIndividu
{
protected:
	String m_name;

public:
	CIndividu();
	CIndividu(String name);
	~CIndividu();

	void Copie(CIndividu const&);
};

#include "CIndividu.h"

CIndividu::CIndividu() : m_name("")
{
}

CIndividu::CIndividu(String name)
{
	m_name = name;
}

CIndividu::~CIndividu()
{
}

void CIndividu::Copie(CIndividu const& I)
{
	m_name = I.m_name;
}

Le code semble fonctionnel

williamlls · March 15, 2021, 8:31pm

Bon il semble que j'ai finalement trouvé l'erreur.
Dans ma classe je n'avais pas ajouter #include<Arduino.h>

Voilà... Si ça peut aider quelqu'un :

system · July 13, 2021, 8:32pm

This topic was automatically closed 120 days after the last reply. New replies are no longer allowed.

Topic		Replies	Views
[Résolu - Merci beaucoup :) ] TaskMe - Mon gestionnaire de tâches ménagères Français	58	2357	July 23, 2021
[Résolu] Compilation : problème Français	4	1637	May 6, 2021
Programme C++ et Arduino Français	5	2416	May 6, 2021
[Résolu] Bibliothèques pour Arduino Français	8	6605	May 6, 2021
Petites précisions s'il vous plaît ? :) Français	3	686	May 6, 2021

Inclure headline dans l'IDE

Related topics