{"id":6881,"date":"2024-02-12T14:56:57","date_gmt":"2024-02-12T20:56:57","guid":{"rendered":"https:\/\/www.logikalsolutions.com\/wordpress\/?p=6881"},"modified":"2024-02-13T08:05:46","modified_gmt":"2024-02-13T14:05:46","slug":"never","status":"publish","type":"post","link":"https:\/\/www.logikalsolutions.com\/wordpress\/information-technology\/never\/","title":{"rendered":"C++ \u2014 Never Do’s"},"content":{"rendered":"\n

No, Never Do isn’t a new loop type though it can be what happens when you ASS-U-ME a default value for a loop variable. These are some things you should never do in your code. I’ve spent nearly 40 years in IT now. For the past decade I’ve been working in the medical device realm. Prior to that I wrote great big boring systems for great big companies. This be what you don’t do in C++ today.<\/p>\n\n\n\n

Never Override && or ||<\/h2>\n\n\n\n

The standard will let you do it, but it will never work correctly. <\/p>\n\n\n\n

All of you know that if the first test fails the second test doesn’t even happen, correct? Not when you override &&. That only happens for the built-in operator. When you declare the && operator for your class, you cannot even be sure which expression will be evaluated first. Think that is a minor inefficiency?<\/p>\n\n\n\n

<\/circle><\/circle><\/circle><\/g><\/svg><\/span><\/path><\/path><\/svg><\/span>
MyBadClass abc;<\/span><\/span>\nMyBadClass def;<\/span><\/span>\nMyBadClass ghi;<\/span><\/span>\nMyBadClass jkl;<\/span><\/span>\n<\/span>\n...<\/span><\/span>\n<\/span>\nif<\/span> ( (abc <\/span>||<\/span> def) <\/span>&&<\/span> (ghi <\/span>||<\/span> jkl) )<\/span><\/span>\n<\/span><\/code><\/pre><\/div>\n\n\n\n
What happens if you’re custom class that overrode these did it because you thought it would be way cool to both step the motor in the robot arm while testing? The last two movements aren’t supposed to happen until the first two have cut as far as needed in a human heart.<\/p>\n\n\n\n
Never Omit {} Around a Single Statement Condition<\/h2>\n\n\n\n
You will actually find that one in the Barr Group Coding Standard for Embedded Systems<\/a>. It’s a good rule. One I arrived at after thinking code “looked better” without them. When you do this<\/p>\n\n\n\n
<\/circle><\/circle><\/circle><\/g><\/svg><\/span><\/path><\/path><\/svg><\/span>
if<\/span> (<\/span>!<\/span>eof)<\/span><\/span>\n   <\/span>idx<\/span>.<\/span>read_next();<\/span><\/span>\n   <\/span><\/span><\/code><\/pre><\/div>\n\n\n\n
is you end up needing some kind of debug statement or additional logic. While it may seem trivial in a 2-line example when you’ve got a screen length if-else-if-else nested to various levels and most having just one line, it’s a house of cards waiting for someone to kick the table. 99 times out of a hundred it’s not even properly aligned.<\/p>\n\n\n
\n
\"\"\/<\/figure>\n<\/div>\n\n
\n
\"\"\/<\/figure>\n<\/div>\n\n\n
I’ve opened up source code that had over a hundred line if statement that looked much like the above only they also indented when the true side of the if had another if.<\/p>\n\n\n\n
Never Put { on the Same Line as Code<\/h2>\n\n\n\n
No, that’s not valid C++. That’s for Java and JavaScript. Again this is one from the Barr Coding Standard and it is a good one. Lots of studies have been done and it is determined that the human brain needs the visual separation. We need to visually know with just a glance what language we are looking at. There have been too many C++ wanna-be languages and now we are in multi-language projects.<\/p>\n\n\n\n
Know this, the embedded systems will be in C\/C++ because you cannot use Python for a medical device. FDA regulations mandate static source code analysis on a type-safe language<\/em>. Sometimes you get forced into situations like this and the boundaries matter.<\/p>\n\n\n\n
<\/circle><\/circle><\/circle><\/g><\/svg><\/span><\/path><\/path><\/svg><\/span>
void<\/span> MainWindow<\/span>::<\/span>menuShortCutsFromScintilla()<\/span><\/span>\n{<\/span><\/span>\n    EdtEditWidget <\/span>*<\/span>ptr <\/span>=<\/span> <\/span>static_cast<<\/span>EdtEditWidget <\/span>*><\/span>( <\/span>m_tabWidget<\/span>-><\/span>currentWidget() );<\/span><\/span>\n    QString keySequence;<\/span><\/span>\n<\/span>\n    <\/span>if<\/span> ( ptr )<\/span><\/span>\n    {<\/span><\/span>\n        Scintilla<\/span>::<\/span>Message msg <\/span>=<\/span> <\/span>static_cast<<\/span>Scintilla<\/span>::<\/span>Message<\/span>><\/span>( SCI_REDO );<\/span><\/span>\n        keySequence <\/span>=<\/span> <\/span>ptr<\/span>-><\/span>editor()<\/span>-><\/span>keyForMessage( msg<\/span>,<\/span> <\/span>1<\/span> );<\/span><\/span>\n<\/span>\n        <\/span>if<\/span> ( <\/span>keySequence<\/span>.<\/span>length() <\/span>><\/span> <\/span>0<\/span> )<\/span><\/span>\n        {<\/span><\/span>\n            <\/span>m_actionRedo<\/span>-><\/span>setShortcut( QKeySequence( keySequence ) );<\/span><\/span>\n        }<\/span><\/span>\n<\/span>\n        msg <\/span>=<\/span> <\/span>static_cast<<\/span>Scintilla<\/span>::<\/span>Message<\/span>><\/span>( SCI_UNDO );<\/span><\/span>\n        keySequence <\/span>=<\/span> <\/span>ptr<\/span>-><\/span>editor()<\/span>-><\/span>keyForMessage( msg<\/span>,<\/span> <\/span>1<\/span> );<\/span><\/span>\n<\/span>\n        <\/span>if<\/span> ( <\/span>keySequence<\/span>.<\/span>length() <\/span>><\/span> <\/span>0<\/span> )<\/span><\/span>\n        {<\/span><\/span>\n            <\/span>m_actionUndo<\/span>-><\/span>setShortcut( QKeySequence( keySequence ) );<\/span><\/span>\n        }<\/span><\/span>\n<\/span>\n        msg <\/span>=<\/span> <\/span>static_cast<<\/span>Scintilla<\/span>::<\/span>Message<\/span>><\/span>( SCI_CUT );<\/span><\/span>\n        keySequence <\/span>=<\/span> <\/span>ptr<\/span>-><\/span>editor()<\/span>-><\/span>keyForMessage( msg<\/span>,<\/span> <\/span>1<\/span> );<\/span><\/span>\n<\/span>\n        <\/span>if<\/span> ( <\/span>keySequence<\/span>.<\/span>length() <\/span>><\/span> <\/span>0<\/span> )<\/span><\/span>\n        {<\/span><\/span>\n            <\/span>m_actionCut<\/span>-><\/span>setShortcut( QKeySequence( keySequence ) );<\/span><\/span>\n        }<\/span><\/span>\n<\/span>\n        msg <\/span>=<\/span> <\/span>static_cast<<\/span>Scintilla<\/span>::<\/span>Message<\/span>><\/span>( SCI_COPY );<\/span><\/span>\n        keySequence <\/span>=<\/span> <\/span>ptr<\/span>-><\/span>editor()<\/span>-><\/span>keyForMessage( msg<\/span>,<\/span> <\/span>1<\/span> );<\/span><\/span>\n<\/span>\n        <\/span>if<\/span> ( <\/span>keySequence<\/span>.<\/span>length() <\/span>><\/span> <\/span>0<\/span> )<\/span><\/span>\n        {<\/span><\/span>\n            <\/span>m_actionCopy<\/span>-><\/span>setShortcut( QKeySequence( keySequence ) );<\/span><\/span>\n        }<\/span><\/span>\n<\/span>\n        msg <\/span>=<\/span> <\/span>static_cast<<\/span>Scintilla<\/span>::<\/span>Message<\/span>><\/span>( SCI_PASTE );<\/span><\/span>\n        keySequence <\/span>=<\/span> <\/span>ptr<\/span>-><\/span>editor()<\/span>-><\/span>keyForMessage( msg<\/span>,<\/span> <\/span>1<\/span> );<\/span><\/span>\n<\/span>\n        <\/span>if<\/span> ( <\/span>keySequence<\/span>.<\/span>length() <\/span>><\/span> <\/span>0<\/span> )<\/span><\/span>\n        {<\/span><\/span>\n            <\/span>m_actionPaste<\/span>-><\/span>setShortcut( QKeySequence( keySequence ) );<\/span><\/span>\n        }<\/span><\/span>\n<\/span>\n        msg <\/span>=<\/span> <\/span>static_cast<<\/span>Scintilla<\/span>::<\/span>Message<\/span>><\/span>( SCI_SELECTALL );<\/span><\/span>\n        keySequence <\/span>=<\/span> <\/span>ptr<\/span>-><\/span>editor()<\/span>-><\/span>keyForMessage( msg<\/span>,<\/span> <\/span>1<\/span> );<\/span><\/span>\n<\/span>\n        <\/span>if<\/span> ( <\/span>keySequence<\/span>.<\/span>length() <\/span>><\/span> <\/span>0<\/span> )<\/span><\/span>\n        {<\/span><\/span>\n            <\/span>m_actionSelectAll<\/span>-><\/span>setShortcut( QKeySequence( keySequence ) );<\/span><\/span>\n        }<\/span><\/span>\n    }<\/span><\/span>\n<\/span>\n    keySequence <\/span>=<\/span> Overlord<\/span>::<\/span>getInstance()<\/span>-><\/span>beginSelectionKeySequence();<\/span><\/span>\n<\/span>\n    <\/span>if<\/span> ( <\/span>keySequence<\/span>.<\/span>length() <\/span>><\/span> <\/span>0<\/span> )<\/span><\/span>\n    {<\/span><\/span>\n        <\/span>m_actionSelectionBegin<\/span>-><\/span>setShortcut( QKeySequence( keySequence ) );<\/span><\/span>\n    }<\/span><\/span>\n<\/span>\n    keySequence <\/span>=<\/span> Overlord<\/span>::<\/span>getInstance()<\/span>-><\/span>clearSelectionKeySequence();<\/span><\/span>\n<\/span>\n    <\/span>if<\/span> ( <\/span>keySequence<\/span>.<\/span>length() <\/span>><\/span> <\/span>0<\/span> )<\/span><\/span>\n    {<\/span><\/span>\n        <\/span>m_actionSelectionClear<\/span>-><\/span>setShortcut( QKeySequence( keySequence ) );<\/span><\/span>\n    }<\/span><\/span>\n}<\/span><\/span>\n<\/span><\/code><\/pre><\/div>\n\n\n\n
If you think that is unreasonable, think again. That’s from a programmer’s text editor that allows one to override default keyboard shortcuts.<\/p>\n\n\n\n
Never Put More Than 130 Characters on a Line<\/h2>\n\n\n\n
Today’s text editors will let you go to unbelievable lengths on a line but it is impossible for programmers to “see” the logic flow when you do that. The Barr standard actually wants less than 80. I understand, but with C++ that isn’t realistic. It’s not just because terminals used to support only 80 columns. Lots of code had to be sent via UseNet or to paper terminals which doubled as printers. We also had IBM TCAM<\/a> to deal with. Because of the additional control codes (<CR><LF><STX><ETX> and a couple others) you could only send 72 printable characters without wrapping.<\/p>\n\n\n\n
Today, in a nice readable font, you can easily display 130 characters. Printers are more than capable of printing 132 characters on a line so nothing wraps when you need to make a printout. Most importantly, if you limit the lines to one screen height per function, a developer can see the flow<\/em>.<\/p>\n\n\n\n
When you open a source file and see a bunch of lines running off the right side of the screen you know that was written by a hack!<\/em><\/strong><\/p>\n\n\n\n
Never Bury a Private Class in a Source File<\/h2>\n\n\n\n
When you see stuff like this<\/p>\n\n\n
\n
\"\"<\/figure>\n<\/div>\n\n
\n
\"\"<\/figure>\n<\/div>\n\n\n
know that you are dealing with an archaic legacy application\/framework. Typically they tried to span languages between C++ and non-type-safe languages like Python, JavaScript, insert-scripting-language-here. The only way they could make that house of cards function was to bury the functionality. If your use case doesn’t fit into the original developer’s tiny mind, you can’t make it work. You have to pull in a ton of their build configuration and dependencies just to override a simple thing. You can read a bit more about this in my Death of Commercial Application Frameworks<\/a><\/em> post.<\/p>\n\n\n\n
None of you write tight enough code to bury it in a hidden class. None of you can make proper decisions for all use cases when it comes to what to make private. If your use case wants\/needs a buried “private” class you can simply inherit private.<\/p>\n\n\n\n
<\/circle><\/circle><\/circle><\/g><\/svg><\/span><\/path><\/path><\/svg><\/span>
class<\/span> MyBetterClass <\/span>:<\/span> <\/span>private<\/span> MyBaseClass<\/span><\/span>\n{<\/span><\/span>\n...<\/span><\/span>\n};<\/span><\/span><\/code><\/pre><\/div>\n\n\n\n
For your use class everything from MyBaseClass will be private in your derived class. If you want almost all of it to be private you can override certain methods and\/or member variables. If they were public in the base class and you want them public (or protected) in your derived class.<\/p>\n\n\n\n
<\/circle><\/circle><\/circle><\/g><\/svg><\/span><\/path><\/path><\/svg><\/span>
class<\/span> MyBetterClass <\/span>:<\/span> <\/span>private<\/span> MyBaseClass<\/span><\/span>\n{<\/span><\/span>\npublic<\/span>:<\/span><\/span>\n   <\/span>using<\/span> MyBaseClass<\/span>::<\/span>nukeSomething();<\/span><\/span>\n   <\/span><\/span>\n <\/span>protected<\/span>:<\/span><\/span>\n    <\/span>using<\/span> MyBaseClass<\/span>::<\/span>visible;<\/span><\/span><\/code><\/pre><\/div>\n\n\n\n
Just remember, you can increase protection when deriving, you cannot decrease it.<\/p>\n\n\n\n
Single Exception to This Never<\/h3>\n\n\n\n
Human\/animal safety is the one time it is recommended to bury access in a hidden private class.<\/p>\n\n\n
\n
\"\"\/<\/figure>\n<\/div>\n\n\n
When you are developing a custom carrier board for a SoM or SoC one can override\/re-purpose a great many of the edge connector pins as well as the expansion and header pins. Any time one of those pins is used for human\/animal safety it is advisable to bury all access to it in a hidden private class.<\/p>\n\n\n\n
What kind of safety? <\/p>\n\n\n\n