Différence entre langage orienté objet et langage procédural

Je suis un étudiant et mon prof m'a dit le langage C est un langage procédural qui est différent des langages orientés objet tel que le JAVA
Mais je comprends pas la différence merci de m'expliquer avec des exemples ;);)

tu aurais dû écouter ton prof...

Sinon va voir sur le forum Général Développement, il y a un débat sur ce sujet...

je vous demande la différence qui est entre langage procédural et orienté objet svp avec les exemples

dans un cas, on définit des procédures, dans l'autre, des objets.

Tu peux donc commencer par chercher ce qu'est une procédure en informatique, ainsi que ce qu'est un objet.

Contrairement à ce qu'on en dit, ces deux propriétés ne sont pas contradictoires.

le C++, le C# ou le python sont les deux (entre autres choses).

Avant, il y avait des langages listings (COBOL par exemple): on prend la première ligne pour aller à la dernière ligne.

Mais on s'est aperçu que dans ce "listing"/ bloc, il y a des redondances. Par exemple, pour afficher ou saisir des données, on fait quasi tout le temps la même chose.

D'où l'idée des langages procéduraux: on va découper ce [gros] bloc et sortir des traitements afin de pouvoir les réutiliser.

L'idée des langages orienté objet: c'est d'aller encore plus loin. On va encapsuler dans une classe à la fois les traitements, mais aussi les variables qui s'y rapportent.
On a dû te parler aussi d'un système de messages entre les objets ;) ;)

Je pense qu'on a fait cela pour des raisons de maintenance/ évolution. Parce que l'on a sorti les traitements du [gros] bloc, on a dû créer des variables globales pour paramétrer/ effectuer ces traitements. Or 1) ceci crée plus de variables 2) on pouvait les modifier et cela posait des problèmes (d'où l'idée de l'encapsulation publique, privée, protégée)

Un des grands principes de la programmation orientée objet est l'encapsulation.

Exemple en langage C :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
// Extrait de String.h
typedef struct String
{
    char* m_data;
        // S'il vous plaît, n'utilisez pas directement m_data.
        // Passez par une fonction de "String.h".
        // Comme ça, je pourrai changer le contenu de cette structure
        // (par exemple pour implémenter la "small string optimization")
        // et l'implémentation des fonctions déclarées dans "String.h"
        // sans que vous n'ayez besoin de changer votre code.
        // Le respect de ce principe s'appelle l'encapsulation.
} String;
    // En programmation orientée objet, on dit que String est une classe
    // et que ses instances sont des objets.
 
void String_Constructor(String* string);
void String_Destructor(String* string);
 
static inline bool String_IsEmpty(const String* string)
{
    assert(string != NULL);
    return string->m_data != NULL && string->m_data[0] != '\0';
}

Deux autres grands principes de la programmation orientée objet sont l'héritage et le polymorphisme d'inclusion.
Exemple très simplifié en langage C :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
// Extrait de ObjetGeometrique.h :
 
typedef struct ObjetGeometrique
{
    void (*m_virtual_transate)(struct ObjetGeometrique*, double, double);
} ObjetGeometrique;
 
static inline void ObjetGeometrique_Virt_Translate(ObjetGeometrique* objet, double x, double y)
{
    (objet->m_virtual_transate)(objet, x, y);
}
// Le premier argument de la fonction ObjetGeometrique_Virt_Translate
// peut être l'adresse de n'importe quelle structure dont
// le tout premier membre est une structure de type ObjetGeometrique.
// Une telle structure peut être vue comme un sous-type de ObjetGeometrique.
// Comme la fonction accepte tous les sous-types de ObjetGeometrique,
// on parle de polymorphisme d'inclusion ou de polymorphisme par sous-typage.
 
// Extrait de ObjetPoint.h :
 
typedef struct ObjetPoint
{
    ObjetGeometrique parent;
    double m_x;
    double m_y;
} ObjetPoint;
// ObjetPoint est un sous-type de ObjetGeometrique
// et possède le contenu de ObjetGeometrique.
// On dit que ObjetPoint dérive de ObjetGeometrique.
 
static inline void ObjetPoint_Translate(ObjetPoint* point, double x, double y)
{
    assert(point != NULL);
    point->m_x += x;
    point->m_y += y;
}
 
static inline void ObjetPoint_Constructor(ObjetPoint* point)
{
    assert(point != NULL);
    point->parent.m_virtual_transate = &ObjetPoint_Translate;
        // Ainsi, quand on appellera ObjetGeometrique_Virt_Translate(point, x, y),
        // cela appellera ObjetPoint_Translate(point, x, y).
    point->m_x = 0;
    point->m_y = 0;
}

Dans la réalité, dans la classe parente, on n'aura pas un pointeur vers une seule fonction, mais un pointeur vers un tableau de fonctions appelé table virtuelle.

Le problème du langage C est qu'il n'est vraiment pas pratique pour faire de la programmation orientée objet.

En C++ et en Java, pour l'encapsulation, à la place d'écrire un commentaire "S'il vous plaît", on peut mettre la visibilité des variables membres en private pour que seules les fonctions associées à la classe puissent accéder à ces variables membres.
En langage C, pour vraiment faire de l'encapsulation, on peut utiliser la technique du pointeur opaque, mais elle réduit les performances.

En C++ et en Java, pour l'héritage et le polymorphisme, au lieu de coder à la main une table virtuelle et des pointeurs de fonctions, le compilateur le fait à notre place.
Pour aller plus loin en C++, lire : FAQ C++ L'héritage.