C++ switch-like code structure

Question

I'm developing a class for connection to LCD (Liquid Crystal Display). It can connect in two modes: 4-bit and 8-bit. And the number of modes may be increased. The mode can be configured in the constructor. A lot of behavior depends on the mode. But! The mode can be changed in run-time, so I can't create the Lcd abstract class and two derivatives FourBitLcd and EightBitLcd. Code:

class Lcd {
public:
    enum Mode {
        Mode4bit,
        Mode8bit,
    };

    explicit Lcd(Mode mode) : mode(mode) {}

public:
    void Init() {
        if (this->mode == Mode8bit) {
            SendCommand(LCD_CMD_8_BIT_MODE);
        }
        else {
            this->Reset();
            SendCommand(LCD_CMD_4_BIT_MODE);
        }
    }

    void SendCommand(uint8_t command_id) {
        
        if (this->mode == Mode8bit) {
            this->SendLowerNibble(command_id);
        }
        else {
            this->SendHigherNibble(command_id);
            this->SendCmdSignals();
            command_id <<= 4;
        }

        this->SendHigherNibble(command_id);
        this->SendCmdSignals();
    }

    void SendData(uint8_t data) {

        if (this->mode == Mode8bit) {
            this->SendLowerNibble(data);
        }
        else {
            this->SendHigherNibble(data);
            this->SendDataSignals();
            data <<= 4;
        }

        this->SendHigherNibble(data);
        this->SendDataSignals();
    }

private:
    
    void BusyCheck() {
        // ...
        
        if (this->mode == Mode4bit) {
            en.Write(true);
            _delay_us(10);
            en.Write(false);
            _delay_us(10);
        }
        
        // ...
    }
    
    void Reset();
    void SendHigherNibble(uint8_t val);
    void SendLowerNibble(uint8_t val);
    void SendCmdSignals();
    void SendDataSignals();

private:
    Mode mode = Mode8bit;
};

In this case, I think I should use polymorphism instead of if/else. But then I have another problem. For example, I can create ModeStrategy abstract class and FourBitModeStrategy and EightBitModeStrategy. But derivative classes need the instance of the class Lcd because they need to use its methods such as SendLowerNibble and SendHigherNibble. But if I pass a pointer of Lcd to derivatives of ModeStrategy then it will be a bidirectional reference. As far as I know, it's not good. For example, code:

class Lcd {
public:
    class ModeStrategy {
    public:
        void InitLcdPtr(Lcd *lcd) {
            this->lcd_ = lcd;
        }

        virtual void InitMode() = 0;

        virtual void SendCommandPart(uint8_t &command_id) = 0;

        virtual void SendDataPart(uint8_t &data) = 0;

        virtual void BusyCheck() {}

    protected:
        Lcd *lcd_ = nullptr;
    };

    class FourBitModeStrategy : public ModeStrategy {
    public:
        void InitMode() override {
            this->lcd_->Reset();
            this->lcd_->SendCommand(LCD_CMD_4_BIT_MODE);
        }

        void SendCommandPart(uint8_t &command_id) override {
            this->lcd_->SendHigherNibble(command_id);
            this->lcd_->SendCmdSignals();
            command_id <<= 4;
        }

        void SendDataPart(uint8_t &data) override {
            this->lcd_->SendHigherNibble(data);
            this->lcd_->SendDataSignals();
            data <<= 4;
        }
    };

    class EightBitModeStrategy : public ModeStrategy {
    public:
        void InitMode() override {
            this->lcd_->SendCommand(LCD_CMD_8_BIT_MODE);
        }

        void SendCommandPart(uint8_t &command_id) override {
            this->lcd_->SendLowerNibble(command_id);
        }

        void SendDataPart(uint8_t &data) override {
            this->lcd_->SendLowerNibble(data);
        }
    };

    friend FourBitModeStrategy;

public:
    enum Mode {
        Mode4bit,
        Mode8bit,
    };

    explicit Lcd(ModeStrategy *mode_strategy) : mode_strategy(mode_strategy) {
        // Bidirectional reference.
        this->mode_strategy->InitLcdPtr(this);
    }

public:
    void Init() {
        this->mode_strategy->InitMode();
    }

    void SendCommand(uint8_t command_id) {
        this->mode_strategy->SendCommandPart(command_id);

        this->SendHigherNibble(command_id);
        this->SendCmdSignals();
    }


    void SendData(uint8_t data) {
        this->mode_strategy->SendDataPart(data);

        this->SendHigherNibble(data);
        this->SendDataSignals();
    }

private:

    void BusyCheck() {
        // ...

        this->mode_strategy->BusyCheck();

        // ...
    }

    void Reset();

    void SendHigherNibble(uint8_t val);

    void SendLowerNibble(uint8_t val);

    void SendCmdSignals();

    void SendDataSignals();

private:
    ModeStrategy *mode_strategy = nullptr;
};

But as I said there is a bidirectional reference. How to solve it? Thanks in advance!

You might want to learn about protected as well as private and public. Derivative classes can access protected functions. — pacmaninbw
– pacmaninbw ♦, Commented Jan 3, 2021 at 12:16

G. Sliepen · Accepted Answer · 2021-01-02 19:33:18Z

Avoid polymorphism in this case

You can avoid the circular reference by passing Lcd * to every member function of ModeStrategy, so the latter doesn't have to store that pointer. However, given the code you have posted, I don't think using polymorphism is a good idea at all in this case. It involves pointer dereferencing and indirect function calls, when all you need is a few if (mode == ...).

Try to minimize the number of functions that need to know the `mode`

Perhaps you can just have a single function that takes care of sending a full byte, whether it's a command or data byte? For example:

void SendByte(uint8_t data, bool command) {
     if (mode == Mode8bit) {
         // write data
         // write command or data signals
     } else {
         // write data
         // write command or data signals
         // write data << 4
         // write command or data signals
     }  
}

Then SendCommand() and SendData() and even Init() can call SendByte() without having to know the mode.

Unnecessary use of `this->`

You almost never need to explicitly write this-> in C++. You are not even doing it consistently anyway, for example in Init() in the non-polymorphic version you call SendCommand() without this->.

Edward · Accepted Answer · 2021-01-06 16:43:12Z

In addition to the existing review, a few other points may be helpful to you.

Rethink the interface

Chances are high that your software can't magically create hardware. In other words, you probably want an instance of your LCD class to access one particular LCD. Therefore you are unlikely to want copy or move constructors, so I would suggest they should be deleted. Further, there's unlikely to be much use in having a separate BusyCheck -- if I were using the code, I'd want the LCD class constructor to be tied to a particular physical LCD and to have functions that print to the LCD. I would expect the class itself to take care of initialization within the constructor and to manage contention.

Think about testing

You do test your code, right? One thing I've used for this is to create a virtual base object with all of the necessary methods, and then derive from that to create the actual object that write to the physical device. During test, I might prefer to have a simulated device, so I create a separate derived object for that purpose. All of the interfaces and interactions remain the same, but it gives you a way to test even in the absence of physical hardware.

Consider initialization and thread safety

Most embedded systems I work with these days are multithreaded. Your system may or may not be, but it's still good to think about. Consider a handheld device in which the top line shows GPS coordinates and time (from a GPS object running in its own thread) and a battery object showing the state of charge (from a Battery object running in a different thread). Both need asynchronous access to the LCD.

Stack Exchange Network

C++ switch-like code structure

2 Answers 2

Avoid polymorphism in this case

Try to minimize the number of functions that need to know the `mode`

Unnecessary use of `this->`

Rethink the interface

Think about testing

Consider initialization and thread safety

You must log in to answer this question.

Hot Network Questions

C++ switch-like code structure

2 Answers 2

Avoid polymorphism in this case

Try to minimize the number of functions that need to know the mode

Unnecessary use of this->

Rethink the interface

Think about testing

Consider initialization and thread safety

You must log in to answer this question.

Related

Hot Network Questions

Try to minimize the number of functions that need to know the `mode`

Unnecessary use of `this->`