Salut
Je me demandais si le constructeur d'une classe est aussi une méthode de l'objet

Ça dépend de ta définition de méthode.

On peut dire que oui en définissant la construction d'un nouvel objet par un appel à "new" qui alloue la mémoire, puis un appel à une méthode pour initialiser les champs de l'objet par le suite.

C'est une méthode qui sert à donner des valeurs aux attributs de ta class, réserver la mémoire nécessaire pour pouvoir utiliser une instance de ta class

Attention que le constructeur n'a pas pour role d'allouer la memoire de l'instance, ceci est fait AVANT, par un mecanisme gere par le compilateur.

Il s'agit de deux choses bien distinctes, et on peut peut les dissocier facilement, c-a-d ecrire son propre allocateur memoire (independamment de l'appel a un constructeur), et appeler directement un constructeur (via un placement new, independamment de l'allocation memoire).

Donc, moi je pensais que un constructeur était une méthode qui prennait un argument en parametre et qui renvoi une valeur qui aura été modifiée en fonction de l'argument qui a été écrit en parametre, tandis que une methode ne prend pas d'argument en parametre (par contre je ne sais pas si il renvoi une valeur ou pas).

Et donc une fonction serais en même temps, une méthode et un constructeur. Je me trompe ?

Ouhla non attention, bcp de confusion -

Une fonction, c'est un bout de code reutilisable, qui peut prendre des parametres, et peut renvoyer un resultat.
Une methode c'est une fonction membre, c-a-d faisant partie de la definition d'un objet
Un constructeur, c'est un mecanisme bien particulier, et qui repond a de nombreuses contraintes du compilateur pour etre utilisable dans le processus de creation d'une instance d'objet.

Yes, tu t'enmêles les pinceaux :
Tu parles toi de procédures et de fonctions qui sont tout deux des méthodes : la fonction renvoie une valeur tandis que la procédure non.
Un constructeur est une méthode particulière qui sert à instancier un objet d'une classe généralement

donc une méthode est par exemple :

class Fruit
{
         public Fruit(){}
}

?

tandis que une fonction s'est :

public int hello() { return blabla;} 

?

Et le constructeur s'est donc le mécanisme qui permet de se servir des méthodes et fonctions de l'objet instancié ?

Et alors une fonction ne renvoyant pas de valeur s'est quoi ?

Je me mélange, et j'ai du mal à comprendre clairement quand vous parlez de "mécanisme particulier"

En gros voilà ( je vais te donner un exemple )

class Objet{

        private : 
               int truc1; // attribut
        public :
               Objet(); //constructeur mais ça reste une méthode
               int truc(); // méthode
};

// plus loin dans ton programme

int afficherUnTruc(double truc){ // ça n'appartient pas à une classe donc c'est une fonction

          std::cout<<truc<<std::endl;
          return 0; // il y a un retour donc c'est bien une fonction
}

void afficherUnTruc2(double truc){

             std::cout<<"jean-machin"<<std::endl; // Aucun retour donc c'est une procédure

}

Qu'est ce qu'il faut retenir de ça :

il y a des "fonctions" qui retournent ou non quelque choses.

Si ça ne retourne rien, on appelle ça une procédure sinon c'est une fonction.
Maintenant quand ta "fonction" est membre d'une classe, on l'appelle alors "méthode", si ta méthode porte le nom de ta classe, c'est donc un "constructeur", attention le constructeur ne porte pas toujours le nom de la classe en POO, en php c'est différent par exemple.

voilà voilà

Le constructeur n'est pas toujours utile et il ne sert des fois à rien ça dépend de ce que tu fais. Si par exemple, tu as fais une classe Personnage, tu as un constructeur mais tu l'utilises pas encore. Dans ta classe personnage, il y a un nom, un prénom et un âge. Là tu te dis, super ma classe est correct, je vais l'utiliser.

Alors tu vas instancier un objet Personnage, lui donner un nom, un prénom et un âge. Maintenant tu te dis que si jamais dans ton programme, on avait besoin d'un personnage et de ses attributs mais que c'était chiant à chaque fois de tout taper au clavier par exemple.

Tu peux utiliser ton constructeur justement pour passer en paramètre un nom, un prénom et un âge pour donner à ton objet ces attributs que tu passes en paramètres.

par exemple :

class Personnage{

       public : 
             std::string _nom; // attribut
             std::string _prenom; // attribut
             int _age; // attribut
             
             Personnage(std::string nom = "dupont", std::string prenom = "jean", int age = 18); // constructeur, on va voir ce qu'il y a en paramètres ;) 

};

Personnage::Personnage(std::string nom, std::string prenom, int age ){

           _nom = nom;
           _prenom = prenom;
           _age = age;

/*
Voilà ce que ça fait, les attributs _nom/_prenom/_age prennent comme valeur les paramètres de ta fonction.
Maintenant si tu ne rentres pas de paramètres, il va prendre les paramètres par défaut, càd

dupont, jean et 18 

*/
}

... quelque part dans ton main

int main(){

         Personnage truc;
         Personnage truc1("Mr", "Beauf", 20);

         truc._nom = "Mr";
         truc._prenom = "Beauf";
         truc._age = 20;

         /*
Là, tu peux constater que truc et truc1 ont exactement les mêmes valeurs d'attributs pourtant ils ne sont pas du tout initialisés de la même façon ! */

         return 0;

}

Donc là dans cet exemple je t'ai montré à quoi pouvait éventuellement servir un constructeur mais il peut servir à autre choses, par exemple, juste afficher "l'objet a bien été créé" par exemple. C'est ce que tu veux pouvoir faire avec ton objet qui détermine si oui ou non il y a besoin d'un constructeur et qu'est ce qu'il va faire surtout !

Tu peux créer une classe Heure qui a 3 entiers, heure, minutes et secondes qui seront, grâce au constructeur définis à 0 dès que l'objet est créé par exemple.

Ensuite, un petit conseil, en informatique, il faut se "segpatiser" càd pas forcément toujours voir plus loin que son nez parce qu'on est pas très intelligents. ;-) On donne des noms compliqués : "récursivité", "méthodes", "procédures".. Mais au final il suffit de regarder le nom d'un truc pour savoir ce qu'il fait.