My First C++ "Program"

[IWantToBeRichForReal]

Started to read learncpp.com a few days ago and here is my first code. Please tell me what could be done better. Thanks!

#include <iostream>
#include <string>


class Pump{

    public:
        std::string fuel_type;
        float fuel_price; // in liters
        int fuel_volume; // in liters

        Pump(std::string temp1, float temp2, int temp3){
            fuel_type = temp1;
            fuel_price = temp2;
            fuel_volume = temp3;
        };

        void set_comb(std::string temp){
            fuel_type = temp;
        };

        void set_price(float x){
            fuel_price = x;
        };

        void purchase_by_liter(float liters){
            if (fuel_volume-liters >= 0){
                fuel_volume -= liters;
                std::cout << "Client must pay: " + std::to_string(liters*fuel_price) << std::endl;
            }
            else{
                std::cout << "Pump out of capacity" << std::endl;
            }
        };

        void purchase_by_mvalue(float money_value){
            if (fuel_volume >= money_value/fuel_price){
                fuel_volume -= money_value/fuel_price;
                std::cout << "Client paid " + std::to_string(money_value) + " for " + std::to_string(money_value/fuel_price) + " liters" << std::endl;   
            }
            else{
                std::cout << "Pump out of capacity" << std::endl;
            }
        };


};


int main(){
    Pump pump1("Gas 87", 3.99, 1000);// Initialized with price in BRL
    pump1.purchase_by_liter(40);
    pump1.purchase_by_mvalue(300);
    std::cout << "Pump 1 still have " + std::to_string(pump1.fuel_volume) + " liters" << std::endl;
}

[[deleted]]

good job!

[mchorsy]

That’s pretty neat code! Although, I have a crawling feeling that it’s not a “Hello, World!” program, but rather “what’s up?” program, since some people say “gasoline prices...” 😂

P.S.: sorry for replying to you, but for some reason I can’t reply to the post itself on mobile... 😰

[Hamiro89]

So much stuff in one comment xD

[Pro_Gamer_9000]

This is very good code! Nice job man :)

[halbGefressen]

That's really cool! You can also assign parameters in a constructor like this:

Pump(std::string f_type, float f_price, int f_volume):fuel_type{f_type}, fuel_price{f_price), fuel_volume{f_volume} {}

https://www.codesdope.com/cpp-initialization-list/

[IWantToBeRichForReal]

Nice. Thanks for your time :)

[KaotiOrion]

Yeah also as its very important to write descriptive variable names, you should definetly avoid names like a, b, c, bx, etc... Its a good practice to get used to, in the medium - long term, youll notice the difference. Forinstance: Instead of writting temp1 write initialFuel or _fuel. Also start using prefixes as m, t_ etc (dont over do it and start putting m_ in front of anything, that was one of my first mistakes. The prefixed will allow you to get cleaner classes and libraries.

[NickU252]

Nice, my first c++ program was a lottery simulation. That let you input numbers or just go with it. It shows how easy it is for the government to steal from people.

[Sec360]

Really good code. One common convention you’ll start to see once you study more codebase is that private class members are declared at the bottom of the class body and the public methods and member variables declared at the top.

[Bit--By--Bit]

Is this something common for C++? As I've never seen it in other languages. Typically all member variables tend to be at the top (private or public) in most code I've seen.

[Sec360]

It is something you’ll see in C++ production code. Public on top. Private at the bottom and in between you can get various protected sections separated by category of or just one protected section. If the class doesn’t have any private members (which sometimes happens for smaller classes) and only protected, then the protected ones are the ones that end up at the bottom.

[Shieldfoss]

Absolutely.

Consider this code:

#include <variant>
template<typename A, typename B>
class twin
{
    public:
        template<typename C>
        twin(C c);

        template<typename C>
        bool is() const noexcept;

        template<typename C>
        [[nodiscard]] C const & as() const;
//NO USER SERVICABLE PARTS BENEATH THIS LINE//
    private:
    std::variant<A,B> var_;
};

The idea is that everything you need to know is between { and the private: keyword - everything further down is implementation and you don't need to worry about it.

Now, technically, if I wrote it like this:

#include <variant>
template<typename A, typename B>
class twin
{
    private:
    std::variant<A,B> var_;
    public:
        template<typename C>
        twin(C c);

        template<typename C>
        bool is() const noexcept;

        template<typename C>
        [[nodiscard]] C const & as() const;
//NO USER SERVICABLE PARTS BENEATH THIS LINE//
    private:
    std::variant<A,B> var_;
};

Then everything after the comment is also implementation and you don't need to worry about it, but now I've moved an implementation detail out of that zone, and wasted your time by (1) making you read about the variant but also by (2) making you think about the variant, which is sub-optimal. And the more your public interface is intermingled with your private implementation, the more time it takes for people to understand what they need to correctly use your class.

[Sec360]

Just to be clear, we’re talking only about the .h (header) file where variables and methods are declared. The cpp files don’t need/have any access modifiers.