Comment utilisez-vous des jeux et obtient en C ++?

Question

Je les ai utilisé en Java et ne semble pas avoir trop de problèmes, mais je ne suis pas les saisir très bien en C ++. L'affectation est:

Write a class named Car that has the following member variables:

    year. An int that holds the car's model year.
    make. A string that holds the make of the car.
    speed. An int that holds the car's current speed.

In addition, the class should have the following member functions.

    Constructor.  The constructor should accept the car's year and make 
        as arguments and assign these values to the object's year and 
        make member variables.  The constructor should initialize the 
        speed member variable to 0.

    Accessors.  Appropriate accessor functions should be created to allow 
        values to be retrieved from an object's year, make, and speed 
        member variables.

    accelerate.  The accelerate function should add 5 to the speed member 
        variable each time it is called.

    brake.  The brake function should subtract 5 from the speed member 
        variable each time it is called.

Demonstrate the class in a program that creates a Car object, and then 
    calls the accelerate function five times.  After each call to the 
    accelerate function, get the current speed of the car and display 
    it.  Then, call the brake function five times.  After each call to 
    the brake function, get the current speed of the car and display it.

Jusqu'à présent, c'est ce que j'ai, mais je suis raisonnablement certain que je suis tout à fait tort. Si quelqu'un a des conseils que je voudrais vraiment l'apprécier, merci!

#include<iostream>
#include<string>

using namespace std;

class Car
{
    public:
        int year;
        string make;
        int speed;
    Car()
    {
        setYear(newYear);
        setMake(newMake);
        setSpeed(0);
    }

    void setYear(int newYear)
    {
        year = newYear;
    }
    void setMake(string newMake)
    {
        make = newMake;
    }
    int getYear()
    {
        return year;
    }
    string getMake()
    {
        return make;
    }
    int accelerate(int speed)
    {
        return (speed+5);
    }
    int brake(int speed)
    {
        return (speed-5);
    }
};

int main()
{
    return 0;
}

PS: Le principal a return 0; purement en tant que porte-lieu juste essayer de comprendre l'ensemble « get et set » chose.

Answer 1

En général vos get / fonctions de jeu devrait fonctionner correctement. D'autres commentaires:

• Le year, les variables make et speed devraient probablement être privé, sinon il n'y aurait pas vraiment besoin d'avoir des fonctions get / set pour eux, car les variables pourraient aussi bien être modifiées directement.
• Probablement il ne devrait pas y avoir de réglages des fonctions du tout. Je ne pense pas qu'il est destiné à être le changement possible du year ou make ou régler directement la speed.
• Le constructeur devrait prendre newYear et newMake en tant que paramètres.
• accelerate() et break() devrait changer le speed enregistré dans l'objet de voiture, non seulement renvoient une valeur différente de speed.
• using namespace std; peut importer beaucoup de noms inattendus à l'espace de noms global et il est souvent préférable d'utiliser des noms explicitement qualifiés comme std::string à la place.

Answer 2

Quelques problèmes que je vois:

Vous faites référence à des variables du constructeur qui n'ont pas été transmis au constructeur (newYear, newMake)

Les fonctions de accelerate et decelerate ne modifient pas l'état; ils ajoutent juste et soustraient 5 à partir d'une vitesse qui est passé à - je ne pense pas qu'ils sont censés se comporter de cette façon. Notez que la description du problème dit qu'ils ajoutent à / soustraire de la speed variable membre .

Toutes vos variables membres sont publiques. Voulez-vous le faire en Java?

Answer 3

Vous voulez probablement rendre les variables internes privées car elles ne doivent être mis à jour par des méthodes à l'intérieur de la classe. Deuxièmement, vous avez besoin des paramètres au constructeur de sorte que vous pouvez définir l'année et faire au départ.

Ex:

public: Car(int newYear, string newMake) {...}

class Car
{
private:
        int year;
        string make;
        int speed;
public:
    Car(int newYear, string newMake)
    {
        setYear(newYear);
        setMake(newMake);
        setSpeed(0);
    }
    ...
}

Vous n'êtes pas non plus mettre à jour les valeurs de la vitesse sur vos méthodes de accelerate et brake. Essayez:

return (speed -=5);

ou

return (speed += 5);

Answer 4

Les fonctions de accelerate() et brake() devraient fonctionner sur l'élément de speed au lieu de simplement retourner la valeur modifiée. Cela signifie que l'affectation à speed selon le cas.

En outre, les membres qui ont accesseurs sont habituellement faites private ou protected au lieu d'être laissés public.

Answer 5

Le getter et setter procédé est utilisé pour réaliser l'encapsulation de données, de sorte que seuls les membres de la classe peuvent uniquement des données d'accès des membres de la classe.

Answer 6

Plusieurs commentaires:

   
1. Vos variables membres doivent être fonctions privées , pas encapsulation publique comme ce qui les rend des pauses publiques et des défaites dans le but d'y accéder en utilisant accesseur (getter / setter).
   
2. Vos noms de fonctions et paramètres de la fonction éclipser les noms de vos variables membres, qui conduit à la confusion. Tout comme en Java où vous devez utiliser this.x pour distinguer la variable membre « x » du paramètre « x », vous devez utiliser de la même this->x. Cependant, cela peut être évité si vous donnez toujours vos variables membres une sorte de préfixe. Deux conventions communes sont préfixer les variables membres avec un trait de soulignement (nommer par exemple votre membre _speed variable et utiliser speed comme le nom d'un paramètre) ou d'utiliser un « m » (pour « membre ») suivi d'un trait de soulignement.
    
3. Toutes les fonctions qui ne modifie pas les données - par exemple, toutes vos fonctions « getter » - doit être déclarée avec le mot-clé const , de sorte que ces données sont accessibles à partir d'un ou const Car const Car&. Par exemple, utiliser int getSpeed()const au lieu de int getSpeed() déclarer constante.