Take Up Code

C++ gives you the power to do great things and multiple inheritance is one of the most powerful tools you will have. This does not mean that you should always use it. Use it when it is the right tool for the job just like any other tool. I will show you in this episode how to use multiple inheritance properly.

How do you test changes in a large project? This question was asked during a recent live weekend class by Rushton W. In the class, I was explaining the benefits of compiling and testing changes often and Rushton wanted to know how this worked in a large application like might be found in a major software company.

This is an advanced C++ topic so do not get worried if it is difficult right now. You will rarely need to use private inheritance. And protected inheritance is probably even more rare. Some of my programming books just say that this whole topic is: beyond the scope of this book. I will do my best to explain this concept because that is what this podcast is all about. You get to learn from my experience.

Declaring that a class is another class type is only part of the reason to use inheritance. It is actually much more powerful than just allowing you to refer to a group of different class instances all by some common base type. When you create a new class that derives from a base class, you can actually change the behavior of the base class methods to adapt them to the specific needs of the new derived class.

Class relationships bring out the full power of object-oriented programming. Inheritance allows you to create classes that specialize or extend other classes. You can create entire hierarchies of classes but there are enough gotchas that some languages have restricted inheritance. This episode will not only explain what inheritance is but give you some guidance on how to use it wisely.

When defining what data and methods belong to a class, you also get to set accessibility levels so that some things are available for general use while other members are more restricted. Why not just make everything available? Then you do not have to worry about it, right? Learning proper access control will help you write code that is actually easier to understand and easier to use. This episode will explain why.

What are logical operators? I sometimes find this question asked online and thought it would be good to explore. There are only three and you might think you already know how to understand them. But have you heard of short circuit evaluations? If you do not fully understand how logical operations can sometimes exit early, then at best, you are going to write some inefficient code. And most likely, you are going to introduce some hard to find bugs.

Creating instances in C# is a bit different because there is a difference between value types and reference types. You will be able to navigate your objects with ease after this episode.

You are ready now to apply what you have learned about class definitions, pointers, and constructors and destructors to be able to create new instances in the main computer memory. There are some fundamental differences between C++ and C# that we are going to again focus on just C++ first and then explore C# tomorrow.

C# calls them finalizers and that is strangely appropriate because all you really know about them is that they might eventually be called, finally. This is because C# decided to manage object lifetimes for you so you normally do not need to worry about leaking memory anymore. This is called garbage collection. The problem with this is that you now have other things to worry about.