[C++] règles de programmation objet [RESOLU]

Destroyers · Le 22/04/2015, à 15:46

Bonjour à tous

je me cultivais sur l'héritage multiple quand, a force de cliquer sur plein de liens me faisant tomber sur des sujets totalement autres, je suis tombé là dessus.

Alors que je suis en train de coder une classe représentant un fichier, je me demandais... est-ce une classe à sémantique de valeur ou d'entité ?

classe Basic_File
{
public:
Basic_File(std::string const &path);
virtual ~Basic_file();      //faut bien supprimer le pointeur qu'est m_file ;)

//plein de méhodes: create, move, rename, remove ...

protected :  //oui j'ai plein de classes dérivées après ^^
std::string m_filePath;
std::fstream *m_file
};

Étant donné que j'ai du redéfinir mon destructeur, ma classe possédant un pointeur, selon la règle des grands trois (Big rule of three), je devrais aussi redéfinir le constructeur de copie et l'opérateur d'affectation... Si ma classe a une sémantique de valeur, ce que je n'arrive pas à déterminer...

Merci de votre future aide

Dernière modification par Destroyers (Le 23/04/2015, à 17:27)

grim7reaper · Le 23/04/2015, à 13:05

Salut,

Pour moi, un fichier serait représenté par une classe à sémantique d’entité.

Destroyers a écrit :

Étant donné que j'ai du redéfinir mon destructeur, ma classe possédant un pointeur, selon la règle des grands trois (Big rule of three), je devrais aussi redéfinir le constructeur de copie et l'opérateur d'affectation... Si ma classe a une sémantique de valeur, ce que je n'arrive pas à déterminer...

Premier point : la « règle de trois » en C++ n’est pas absolu (mais c‘est une bonne indication), il ne faut pas l’appliquer à l’aveugle.

https://en.wikipedia.org/wiki/Rule_of_three_%28C%2B%2B_programming%29 a écrit :

The rule of three (also known as the Law of The Big Three or The Big Three) is a rule of thumb in C++ (prior to C++11) that claims that if a class defines one of the following it should probably explicitly define all three.

En C++11 c’est même devenu « règle de cinq ».

Deuxième point : le fait de définir explicitement ces trois opérateurs ne fait pas de ta classe une classe à sémantique de valeur. Cela va dépendre de comment tu les définis.
Par exemple, pour une classe à sémantique d’entité tu peux les définir explicitement comme étant non utilisable (depuis le C++11 c’est très simple).

Destroyers · Le 23/04/2015, à 14:21

Ah merci ton lien m'apprend un truc utile.
C'est vrai que je vois mal l'utilité de copier un objet issu de cette classe ... je vais de ce pas me contenter de supprimer la définition du constructeur de copie et l'opérateur d'affectation.
En revanche, ma classe est dérivée 4 fois:
Basic_File ==> File ==> KeyWordFile ==> GroupedKeyWordFile
du coup... dois-je mettre ces fonctions en virtuel ? dois-je les réécrire dans chaque classe ?

virtual Basic_File(const Basic_File &) = delete; 
virtual Basic_File &operator=(const Basic_File &) = delete; 

//dois-je réécrire ces lignes dans toutes mes classes ?

Tu parles de règle de cinq, tu pourrais me dire quelles sont ces 5 méthodes maintenant ?
Et au delà de ça, pour m'aligner avec le titre du topique, où pourrais-je trouver un condensé des règles de programmation orientée objet (en Français) ?
(ou alors qu'on me les dise ici ^^)

car je connais le fait que:
-il doit être possible d'utiliser un objet d'une classe dérivée partout où l'on peut utiliser un objet d'une de ses classes mères.
-il doit être possible de faire une affectation d'une classe dérivée vers une classe mère.
-les pointeurs des classes dérivées doivent être compatibles avec les pointeurs des classes mères. Cela signifie qu'il est possible d'affecter un pointeur de classe dérivée à un pointeur d'une de ses classes de base.
-les attributs ne doivent jamais être directement accessibles de l’extérieur de la classe (encapsulation)
-je connais maintenant la règle de 3 (apparement 5 maintenant ? plus d'info pliz )

Mais je suis certain que ces quelques règles ne sont qu'une base et qu'il exise des notions plus avancées.

Merci pour votre aide.

grim7reaper · Le 23/04/2015, à 15:41

Destroyers a écrit :

Ah merci ton lien m'apprend un truc utile.
C'est vrai que je vois mal l'utilité de copier un objet issu de cette classe ... je vais de ce pas me contenter de supprimer la définition du constructeur de copie et l'opérateur d'affectation.
En revanche, ma classe est dérivée 4 fois:
Basic_File ==> File ==> KeyWordFile ==> GroupedKeyWordFile
du coup... dois-je mettre ces fonctions en virtuel ? dois-je les réécrire dans chaque classe ?

Il me semble qu‘il est inutile d’utiliser virtual ici.
Non, pas besoin de les réecrire dans les classes filles tant que tu ne redéfinis pas ces fonctions. Les implémentations par défauts vont appeler les fonctions de la classe parente (fonctions qui n’existent pas) et donc tu devrais bien avoir une erreur à la compilation.

Destroyers a écrit :

Tu parles de règle de cinq, tu pourrais me dire quelles sont ces 5 méthodes maintenant ?

Elles sont dans la page Wikipedia que j‘ai cité, les deux nouvelles méthodes sont lièes à la move semantic.

Destroyers a écrit :

Et au delà de ça, pour m'aligner avec le titre du topique, où pourrais-je trouver un condensé des règles de programmation orientée objet (en Français) ?

Le blog d’Emmanuel Deloget contient d’excellent articles à ce sujet, dans la catégorie « Architecture Orientée Objet ». Il y présente, entre autres, les principes de bases que sont la loi de Déméter et S.O.L.I.D.

Destroyers · Le 23/04/2015, à 17:27

Merci c'est très complet.

Je vais devoir me pencher un certain temps sur cette Move sementic car elle me parait assez abstraite.

Destroyers · Le 29/04/2015, à 21:40

En revanche, quand je compile, il me sort toujours:

src/Basic_File.hpp:42:45: warning: defaulted and deleted functions only available with -std=c++11 or -std=gnu++11 [enabled by default]
   Basic_File(Basic_File const &OtherFile) = delete;
                                             ^
src/Basic_File.hpp:75:47: warning: defaulted and deleted functions only available with -std=c++11 or -std=gnu++11 [enabled by default]
   Basic_File &operator=(const Basic_File &) = delete; 
                                               ^

alors que dans mon makefile, c'est bien le premier argument que j'envoie au compilateur:

CC = g++

RM = rm -rf

CFLAGS = -std=c++11 -Wall -Wextra -pedantic -Wshadow -Wpointer-arith -Wcast-qual -Wcast-align -Wfloat-equal -Woverloaded-virtual -Winline -Wconversion -Wwrite-strings -Weffc++ -Wswitch-default -Wundef -Wlogical-op -Wunused -Wuninitialized -Werror -Os -s -O2
SFML = -lsfml-system -lsfml-window -lsfml-graphics -lsfml-network -lsfml-audio

NAME = file

BINDIR = bin

SRCDIR = src

SRCS =  $(SRCDIR)/main.cpp \
  $(SRCDIR)/Basic_File.cpp	\
  $(SRCDIR)/File.cpp  		\
  $(SRCDIR)/KeyWordFile.cpp  		\
  $(SRCDIR)/GroupedKeyWordFile.cpp 	\
  $(SRCDIR)/Encoder.cpp		\
  $(SRCDIR)/Hasher.cpp  \
  $(SRCDIR)/Scrambler.cpp

OBJS = $(SRCS:.cpp=.o)


all: $(NAME)

$(NAME): $(OBJS)
	$(CC) $(OBJS) -o $(BINDIR)/$(NAME) $(CFLAGS) $(SFML)

clean:
	$(RM) $(SRCDIR)/$(OBJS)

fclean: clean
	$(RM) $(BINDIR)/$(NAME)

re: fclean all

.PHONY: all clean fclean re

comment faire pour désactiver ce warning gênant ? (de plus, pourquoi est-ce un warning alors que j'ai également Werror ? mes arguments ne seraient-ils pas pris en compte ? mon makefile est il mauvais ?)

Dernière modification par Destroyers (Le 29/04/2015, à 21:41)

Compte anonymisé · Le 30/04/2015, à 07:15

En quoi ce Warning est-il gênant ?

Destroyers · Le 03/05/2015, à 16:56

on m'a appris a considérer tout les warnings comme des erreurs.
Un warning ça fait pas propre. Mais au delà de ça, ce warning devrait être une erreur puisque j'ai envoyé -Werror au compilateur, à croire qu'il ne prend pas mes arguments en compte. mon Makefile est-il correct ?

eiger · Le 04/05/2015, à 15:52

Destroyers a écrit :

Mais au delà de ça, ce warning devrait être une erreur puisque j'ai envoyé -Werror au compilateur, à croire qu'il ne prend pas mes arguments en compte. mon Makefile est-il correct ?

J'aurais en effet tendance à dire que ton Makefile n'est pas tout à fait correct, et que tu n'envoies pas -Werror au compilateur.

Tu as défini la variable CFLAGS et tu l'utilises explicitement pour passer des objets à l'exécutable. Mais qu'en est-il du passage des fichiers sources .cpp aux objets ? Ton Makefile ne contient aucune règle explicite, donc make va utiliser les règles par défaut (https://www.gnu.org/software/make/manua … Rules.html). Or pour le C++, c'est la variable CXXFLAGS qui est passée par défaut, et non CFLAGS.

Essaie donc de renommer ton CFLAGS en CXXFLAGS.

Destroyers · Le 04/05/2015, à 18:46

O.... M..... G.....
j'ai plus de 300 lignes de warnings (enfin... d'erreurs, du coup !)
j'en conclue donc qu'en effet AUCUN de mes arguments n'étaient pris ...
Merci beaucoup, ça marche

Ubuntu-fr

Navigation

Liens de recherche

Annonce

#1 Le 22/04/2015, à 15:46

[C++] règles de programmation objet [RESOLU]

#2 Le 23/04/2015, à 13:05

Re : [C++] règles de programmation objet [RESOLU]

#3 Le 23/04/2015, à 14:21

Re : [C++] règles de programmation objet [RESOLU]

#4 Le 23/04/2015, à 15:41

Re : [C++] règles de programmation objet [RESOLU]

#5 Le 23/04/2015, à 17:27

Re : [C++] règles de programmation objet [RESOLU]

#6 Le 29/04/2015, à 21:40

Re : [C++] règles de programmation objet [RESOLU]

#7 Le 30/04/2015, à 07:15

Re : [C++] règles de programmation objet [RESOLU]

#8 Le 03/05/2015, à 16:56

Re : [C++] règles de programmation objet [RESOLU]

#9 Le 04/05/2015, à 15:52

Re : [C++] règles de programmation objet [RESOLU]

#10 Le 04/05/2015, à 18:46

Re : [C++] règles de programmation objet [RESOLU]

Pied de page des forums