Take Up Code

Can you change an int into a float? And because an int occupies multiple bytes in memory, can you get access to the individual bytes by themselves? Or what if you have a derived class and you want to refer to it as if it was a base class? And can you go the other way, from base class to derived class? These are the topics I will be explaining today.

Declaring methods inside classes is great but what do you do when you want a method you can call anytime? If you are using C++, then just write a method. But if you still want your method in a class or if you are using C# where all methods need to be in classes, then you will need to make your method static. And you can declare static data too. What does that do?

Your classes will likely have data members so how do you work with these data members? Should they be public? Private? Do you let other code access them directly? And what is the difference between a field and a property? This episode will help you get and set your data members.

How are namespaces and include files related and why do we need both?

Interfaces give you the ability to define behavior without actually implementing it. Why would you want to do that? Your classes can then declare support for interfaces which means that they promise to support that behavior. How your classes do this is up to them. Declaring support for an interface signals that they do this. You can have what might be completely unrelated classes all supporting the same interface which then allows you to work with them in the same way.

What if you were writing a class that you wanted to be a base class? A class designed from the very beginning to bring together other classes with common behavior. What if you also wanted to guarantee that this class could never be created by itself? That it must always exist as a base class for some other class? All you have to do is make your class abstract. Then it can only be instantiated as part of another class that derives from your class. This episode will explain why you might want to do this and how.

Composition allows you to specify very different kinds of relationships between classes. This is sometimes also called containment. If you are building a racing game and have a car class and a wheel class, you would not want to say that cars are wheels but instead that cars have wheels. Proper use of composition will even allow you to substitute what kind of wheels your cars have. This can not only simplify your designs but make your code easier to test.

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.

One of the biggest differences between C++ and C# is in how object lifetimes are managed. I was going to have a general topic on destructors just like constructors but there are just too many differences. So today, we are going to look at C++ destructors.

What is the best way to handle errors? Things will not always go the way you expect and you are going to need to plan how to handle errors. Should you use return codes or exceptions? Plus, this episode will help you in other ways. You will be glad you listened.

Constructors are your first opportunity to make sure your custom types are well formed. This episode explains the different kinds of constructors and how you should use them.