Tag: Udemy

Beginning C++ 53-61: Arrays and Vectors

Arrays and Vectors?? I know that an array is like a collection of values. I also know that vectors are used for describing direction and speed in maths. I don’t think that’s the same here.

Well, time to learn some new concepts of the C++ programming language.

If you’re interested in taking the course yourself, you can find it on Udemy.

This is not the array you’re looking for…

Lecture 53: Section Overview

So just a brief overview of the section again.

Arrays and vectors are compound data types. That is datatypes that are made up of other data types. Vectors are the way to go in modern C++ and the course will dive deeper into this later.

Lecture 54: What is an Array?

As mentioned in the overview, an array is a collection of elements of the same data type.

This means you can for instance make an array of strings, call the array Names and use this to address all the names. You can then go through the list, read each name and then put it into some output. Much better than using say 100 different variables called name_1, name_2 etc.

But arrays also have some limitations. One is that it’s a fixed size. If you define it to have space for 100 names and you need to add name 101, then you’re out of luck and need to change the program.

You also need to keep track of how many elements the array has yourself. If you have 100 elements, but ask to read element 123, the program will read some data from memory and spit it back at you, but it probably won’t be useful.

The worse thing is that you can also change elements that are out of bounds. That means you will write data into memory that might be used by other programs and have the potential to crash the computer.

But an array is very efficient and easy to loop through, so it’s a nice tool to have. Just remember that the first element in the list has address 0, not 1. So an array with size of 100, goes from 0-99. If you go from 1-100, you can and probably will end up in trouble.

Lecture 55: Declaring and Initializing Arrays

Here we go through how to declare an array.

It’s pretty easy and straightforward. Just remember you have to set it’s type and size when declaring it. As always it’s good practice to initialize a list when you declare it.

Actually, as it turns out, I lie. Just goes to show that a little knowledge can be dangerous. 🙂
If you provide a list of values you can omit setting the size and the compiler will set the size based on the number of elements in the list you provide.

Lecture 56: Accessing and Modifying Array Elements

Here we learn how to access the individual elements of the array to get the value of that element. The instructor goes through how this works in the background and what the compiler does. He then shows you practical examples in CodeLite and also shows how you can easily crash your program.

It’s explained clearly and it’s pretty easy so shouldn’t give you any problems. Just remember that the compiler does NOT check that you are keeping yourself inside the array.

Lecture 57: Multidimensional Arrays

Sometimes you need more dimensions and C++ supports this. You declare, initialize and use it in the same way as normal arrays by using [] and {}.

Really nothing special about this, you just introduce more dimensions into the array.

That is some nice vectors. 🙂

Lecture 58: Declaring and Initializing Vectors

A vector is defined in the C++ Standard Template Library. It has many of the same characteristics as arrays, but with added bonus features. Since it’s part of the library it already has built-in functions that you can use in your code. This can be things like sorting, finding an element and more.

I’m really looking forward to learning more about the STL as that has been lacking in the other courses I have taken. And there’s a whopper of a section on STL later in this course. It’s 28 lectures long, so it’s longer than many full courses on Udemy. 🙂

Vectors can be defined as a dynamic array, where the size can grow or shrink as needed. This is much better than arrays as you are using the exact memory needed to hold the data. With arrays, you had to declare the size up front, so you could up end up wasting memory or find yourself going outside the array with unknown consequences.

After seeing the summary in this lecture I really understand why Frank earlier said that you mostly use vectors in modern C++. They just seem better in every which way.

Lecture 59: Accessing and Modifying Vector Elements

Again we see that arrays and vectors are much alike, as you can use the exact same syntax as with arrays. But then you also have the same limitations, for instance, the possibility to go outside the vector.

And here we get to see the object-oriented part of C++. Vectors have several methods of accessing and modifying it. We also see that if you try to modify something outside the scope of the vector using these methods, the program will now crash with an error message instead of doing something potentially dangerous to your computer.

The error message you get can be pretty daunting, but the instructor explains it in a clear way, showing you what to look for. And that is pretty important. Some people panic when they see an error message because it can be just too much information. Getting shown what to look for is invaluable.

The instructor again uses practical examples in CodeLite to explain and sell vectors over arrays. I now understand even clearer why vectors come with huge benefits over arrays.

Lecture 60: Section Challenge and Quiz

The challenge was again pretty straightforward. The instructor asked us to create 2 vectors, add some data to them and then print them out. We were then going to create a 2D vector and add the first two vectors to that and display the content. Again pretty easy.

But now comes the surprise. Frank asks us to change the first element in the first vector we created and then display the content of the 2D vector again. I thought that we might get a change of value in the 2D vector, but we didn’t. The content was still the same.

That’s because when we added the element, we copied the content from the first vector into the 2D vector. So when we changed the first vector, the copy did not change. Interesting and pretty important to know, so was nice to see how it works in practice.

Later we will learn about vectors of references and pointers, which will behave differently and where we can do what I thought was going to happen.

My solution was pretty close to the instructors. After all, it was pretty straightforward and not terribly advanced. I did throw in some for-loops when I was displaying the data though, just to see if I remember how to do them.

I also did some experimentation with the size()-method on the 2D-vector to find out how you find the sizes of the internal elements. It worked out to be pretty easy. So that’s why my vector1 contains three elements instead of just 2.

And it worked 🙂

As always all my trial code and challenge solution can be found on my GitHub.

The quiz this time was a little more complex and I had to think more. I almost failed one, but with a little bit more thinking I saved my honor and got a 10 out of 10 score. 🙂 But again I miss a little more feedback than just “Good job!” when you answer correctly.

June 27, 2018
Beginning C++ 36-42: Structure

This section teaches us the structures of a C++ program. C++ being a static language imposes some pretty strict rules on what you can do and not, so learning how a program is structured is pretty important.

These early videos don’t really do much coding, so there’s not really much to do for me here other than summarize them. Hopefully, there will be more coding later where I can show you my solution and my thoughts behind it.

The structure of a C++ program is very important.

Lecture 36: Section Overview

Again the section starts with a quick overview of what we will go through in later videos. Always nice to have some knowledge of what you are going to learn before you get the details.

Lecture 37: Overview of the Structure of a C++ Program

This lecture starts by showing us the keywords of C++. It has over 90(!) defined keywords, which is much more than many other languages. Luckily many of them are not used so you don’t have to remember all 90.

Then the video goes on to talk about identifiers and what’s the difference between them. It also gives you a quick overview of operators and points out some specific C++-operators. Lastly, we go into punctuation and show some examples of that.

All of these elements put together gives us the syntax of C++.

Lecture 38: #include Preprocessor Directive

Here the instructor gives us a brief overview of what the preprocessor is and what it does.

It’s a program that goes through the code before the compiler gets hold of it. It doesn’t do anything with the C++ code, nor does it understand it. It just goes through the source code, does some finessing with it and then spits it out and into the compiler.

Lecture 39: Comments

// This is a one-line comment.

/* These lines of code
are comments that go
of several lines, aka. a multi-line comment. */

I saw somewhere else that comments using // was the C++ style code, while /* */ was C-style. Don’t know if anyone can confirm or deny that?

Comments should just be used to explain complicated code. Clear to understand and obvious code doesn’t need comments.

The course also discourages the use of comments for version control. It’s much better to use Git, Subversion or other systems to get real version control of the source code.

BTW, one of the jobs of the preprocessor is to strip the source code of comments so the compiler doesn’t have to bother with them.

This main() course looks SOOOO good! 🙂

Lecture 40: The main() function

Now we’re coming to the main() course. 😀

The main()-function is an important part of a C++ program as each program must have one, and only one, main() function. This is where the program starts its execution, so whatever your program does, it all starts here. Most of the code is actually not in the main() function at all, but without it the program won’t do anything.

The course describes two different versions of main, depending on if the program accepts command line arguments or not, int main() or int main(int argc, char* argv[]).

In another course I take I see them using void main(…). After watching this lecture I wanted to find out why they do it differently, and the answer is that one does it right and the other one doesn’t.

The correct way to do it is to use int main(…). The using of void main(…) is something that Microsoft Visual Studio allows, but it is just wrong and should not be done. Trying it with g++, as is the compiler used in this course, will give you an error message.

Lecture 41: Namespaces

Namespaces are a way to avoid conflicts between different libraries or frameworks that might have functions with the same name. Using namespaces and the scope resolution operator (::), will avoid using the wrong function.

C++ has a “standard” namespace called std. Those three letters plus the two ::’s are something you will learn to type a lot.

You can use a directive to avoid typing the namespace names all the time, but it comes with some dangers. This is fine for small programs, but large and complex programs should avoid this to make sure you don’t use the wrong function due to a naming conflict.

Lecture 42: Basic Input and Output (I/O) using cin and cout

Most of the other videos in this section has been around the 3- to 4-minute mark, but this video comes in at a whopping 20+ minutes. Time to prepare for a HUGE chunk of info.

We learn about cin, cout, cerr and clog and more from iostream. This is really the first course I’ve taken that mentions cerr and clog. Probably because it’s mostly not used, but again this is a nice touch and shows that this course goes deeper than most.

Another nice point is that Frank, the instructor, talks about the difference between using \n and using endl when adding a line break. For the user, it looks the same, as the end result is that the next text that is written goes to the next line, but behind the scenes, there is a difference. Especially when working with files you will want to be aware of the difference.

The instructor also goes quickly through the pitfalls of using cin for reading inputs.

The lecture ends with examples of everything that’s talked about and again Frank does a pretty good job of explaining what happens and why you need to be careful when using cin. He actually says that usually, you don’t use cin to get user input without going into further explanation. I guess we will come back to that later.

Quiz 2: Section 5 Quiz

So no Section Challenge this section, but a nice little quiz. We didn’t really learn any new statements etc in this section, so a challenge would really just be a repeat of what we’ve already done in earlier sections.

The instructor sneaks some nice little traps into this quiz, so it’s important to read the questions and answer alternatives thoroughly before selecting your answer. I didn’t so I ended up with just 9 out of 10 correct on the first try. Was pretty easy to figure where I went wrong, but a nice touch from the course so you just don’t cruise through these.

June 12, 2018
Beginning C++ 25-35: Getting Started

So, we are now entering a new section and we are Getting Started. Yeah, that’s the title of the section, so I must believe that we are now finally going to write some code.

Lecture 25: Section Overview

This is just a section overview, just as the title say. Nothing special, let’s continue.

Lecture 26: An Overview of the CodeLite Interface

This is a very nice video as it tells you how you can change the layout of the CodeLite IDE to your own personal preference.

I personally didn’t change it up to much. Just removed a few tabs the Workspace view I don’t think I will be using for now and also moving it to the right side of the window. That way it looks a little bit more like my setup in Visual Studio 2017. I also fiddled around with the themes to find one to my liking and ended up using Tomorrow Night as my theme.

Lecture 27: Writing our first program

We write a small program to type a message to the user and get an answer from him. We started with the template we made earlier, but deleted the source and wrote everything from scratch. This is a nice educational move as it will teach you more about the structure of a C++ program when you have to write everything yourself instead of starting from a random template.

We learn some basic input/output functions of C++ and the difference between the insertion and the extraction operator. There is a small mention of namespaces, variables and how we include libraries.

We end up with a short little program that we compile and hopefully end up with zero errors and warnings. I managed to bork it with some missing colons, but happily nothing I didn’t know how to fix.

The instructor also shows us that since we made our own template and based this project on that, we can see that CodeLite instructs the compiler to use the C++14 standard.

So again nothing special, but this is Beginning C++ after all and we all have to start somewhere.

Lecture 28: Building our first program

We learn more about compiling and building a project. What are source-files, object-files and executable files? The instructor also goes through the different options CodeLite have for compiling, building, rebuilding and cleaning files and projects.

The course also tells us more about the difference of the files we see in the Workspace and what is really on the disk. There are many files on the disk that we as developers don’t need to know about, at least not at this moment, but it’s nice that the course explains them anyway.

For beginners in C++ this is maybe not fully understood right now, but it’s something you need to know when your projects gets bigger and more advanced. But we’re still in the introduction stage learning basics that are important to know to set up your workflow and understand what’s happening if something goes wrong.

Lectures 29-33: What are different types of errors?

These videos goes through the following types of errors:

Compiler errors

The instructor creates a new project and shows us some common compiler errors and some ways on how to fix them.

Compiler warnings

What’s the difference between a warning and an error? Well, here you get an explanation. In short, it’s not “real” errors in your program, but it warns you about things that might give you unwanted or unexpected results.

Seems like g++ is fairly good at giving error messages and warnings that you can understand. And CodeLite also helps you find the error as if you click on an error message, the IDE will jump to the place in the code where the error is reported.

Linker errors

These errors are a little bit more tricky to find. A program might compile without warnings, but when you build it you might get a linker warning. These errors can be more tricky to find in your source.

This is something we probably won’t be having much in this course since we’re doing all the coding ourselves, but when you create large projects and try to link other libraries etc this is something that can happen.

Runtime errors

Runtime errors are errors that happen when you’ve taken care of all the bugs in your program, compiled and built it and made the executable file. Then some user runs your finished program and gets an error and yells at you, even after all your hard work.

These are errors that you can’t really avoid. Sometimes a user gives you strange inputs, a file can be missing or something like that.

These errors can make your program crash, so you have to use Exception Handling to deal with them. Exception handling will be a topic for later in the course.

Logic errors

Logic errors are errors that the compiler won’t help you with and doesn’t stop you from building your program. These errors are made by the programmer during writing of the code.

These errors can really only be found by doing thorough testing of the program before you send it to end users.

Lecture 34: Section challenge

Fairly easy challenge here as everything you need has been shown to you in the previous videos.

What you need to do is to make a program that asks the users for his favourite number and get that from him. You will then say that it’s also your favourite number and confirm that the number the user typed really is your favourite number.

This is the output of my solution to the challenge

If you want to see my solution you can check out this gist. You shouldn’t really need to look at my solution to solve this challenge, but it’s there if you need it.

Lecture 35: Section Challenge – Solution

Well, not surprisingly the solution the instructor shows us are more or less identical to my solution.

Quiz 1: Section 4 Quiz

The section ends with a quiz with 10 questions relating to the topics covered. Shouldn’t be too hard, but it’s nice to get a review of the topics to see if you understood the material.

May 10, 2018
Time Management & Productivity course review
So, the time has come to do a review of the Udemy course Time Management & Productivity.

What is important is seldom urgent and what is urgent is seldom important.
– Dwight D. Eisenhower

The course is designed to get you better at scheduling and managing your tasks using a method called the Eisenhower Decision Matrix. It’s a fairly short course, so I went through all of it in an evening. And these are my thoughts about it.

This course is a hard one to rate fairly for a couple of reasons.
1. It’s short. But does short mean something is bad or of no value? Of course not, sometimes a 10 second pep talk can be all you need to get something done.
2. The material is very well known. Search on Google for “Eisenhower Decision Matrix” and you get 148 thousand hits.
But I’ll make this article pretty short also and say that I’m a little “meh…” about this course.

First reason for that is the cost. They want $49.99 for it, which is WAY to much. I got it on a sale for $10, which I think is the maximum I would pay for this course.

Second, but more importantly is the content of the course. They explain every part of the matrix and how to use it, but I feel that they could have done a better job of giving real life examples of the topics.

There is a video in there which is labeled “Personal Example”, and I’m sure it IS a fairly real example from the instructor. But all he ends up with is to repeat what has already been said on the previous videos.

If you want to learn about this topic and try it out I would recommend you start with this article from The Art of Manliness, The Eisenhower Decision Matrix: How to Distinguish Between Urgent and Important Tasks and Make Real Progress in Your Life.

There is one thing the course does better than that article and that is it’s methodology of HOW you define which of your tasks goes where. In short how they do it is:
1. List all your tasks
2. Rank them first by Urgent or Not Urgent
3. Rank each block into Important or Not Important
And one HUGE point about that 3rd step is that you rank them on the importance FOR YOU! Does the task help you further your goals or is it a task that help some other peoples goals? Only tasks important to you should go in the Important category.

So to sum up, will I recommend the course? If you can get it for cheap, then feel free to do so if you feel you need more than the article I linked above.
If you do some more Googling about the topic and think that is better use of your time, then give this course a pass. If you have some more questions about the topic, then drop a comment below and I will answer to the best of my ability.
May 8, 2018
Beginning C++, section 1-3

I chose to do these three sections in one blog post since they don’t really contain much specific C++ teaching. When I get to more specific lectures I’ll make more in depth posts about what I’ve learned from those lectures.

Section 1 – Introduction

This section goes into why you should learn C++ and a little bit about the history of the language.

The simple reasons the teacher gives for why is two; salary and popularity.

At least in the States it seems like C++ developers can earn good money. How it is over here I don’t know, but I see that there are several open positions for people knowing the language.

The course points to several websites that make different indexes about the popularity of different programming languages. The most interesting link might be a ZDNet-article called Which programming languages are most popular (and what does that even mean)? It is sort of a rundown of all of the other pages linked in the course and it has some discussions about which way to go. You’ll see that C++ is ranked as one of the top 6 popular languages used now and it recommends you choose either C++ or Java as your first language to learn.

Section 2 – Installation and Setup

In this section the course just goes through some of the tools you can use to program C++. The teacher has gone for something that is cross-platform and has low requirements and has ended up with CodeLite as the IDE and they are going to use GNU compilers.

Since I’m using Windows I ended up with using MinGW and CodeLite, but the course also goes through setting up systems for Mac OSX and Ubuntu Linux.

It also links to some websites you can use if you quickly want to test some stuff and don’t have access to your IDE in the moment.

Section 3 – Curriculum Overview

As the title of the section explains pretty good, this is just an overview of what the course will be about and also how the course is built up with lectures and challenges.

May 3, 2018