C and C++

I was given a pop quiz by a non-tech interviewer once on c++. Here was his questions:

1. What is the name of an invalid pointer?
   1. Weird question and I don't think it's right. Answer he was looking for was null.
2. What is the difference between a struct and a class?
3. What is the keyword to deallocate memory? Lol
4. When using a new keyword where is the memory stored, stack or heap? Heap OBVI.
5. If a program crashes and you have a core dump and debugger, what is the first thing you do?
   1. Look at a backtrace, see where the program crashed, look at what the variable were.

Principles of C++: ¹⁾

• Trust the programmer.
• You don't have to pay for something you don't need.
• Don't break existing code.
• Prefer compile time errors over run time errors.

Here are some differences I have come across between C and C++. This stuff is interesting because it highlights the features that make C++ more powerful, and also gives you a better understanding of the way the two languages work.

• Biggest one: C does not have classes and objects
• C++ has pass by reference. C does not.
• C++ implements name mangling when compiling functions, C does not.

Much of what I have learned comes from two places: the GNU CPP manual link and a guide to the CPP link.

__VA_ARGS__ is a CPP (c pre processor) identifier that gets replaced with the values of … when used in a variadic macro.

A simple macro is a kind of abbreviation. It is a name which stands for a fragment of code. Some people refer to these as manifest constants.

Before you can use a macro, you must define it explicitly with the #define directive. #define is followed by the name of the macro and then the code it should be an abbreviation for. For example,

#define BUFFER_SIZE 1020

The use of all upper case for macro names is a standard convention. Programs are easier to read when it is possible to tell at a glance which names are macros.

The C preprocessor scans your program sequentially, so macro definitions take effect at the place you write them.

foo = X;
#define X 4
bar = X;

Produces as output:

foo = X;
bar = 4;

You can also use #defines to define functions.

The do { } while(0) technique in macro definitions is used to avoid issues with generating double expressions caused by the addition of a semicolon. Doing the following:

#define SOME_MACRO(VAR) \
do {    int i = var;    \
        i = 12*i; }     \
        while (0) 

When you call this macro in the your code as SOME_MACRO(var); it expands into one statement which is:

do { ... } while (0); 

This way you can use a macro expansion in a if else statement with no curly braces where more than one statement would mess stuff up.

The STL library has 3 types of container classes:

• sequence containers - container classes that maintain the ordering of elements in the container. Examples are vectors, deques, and lists.
• associative containers - container classes that automatically sort their inputs when the inputs are inserted into the container. Eg. are a set, multiset, map or multimap.
• container adapters - special predefined containers that are adapted to specific uses, such as a LIFO stack or a FIFO queue.

STL containers provide a mechanism for traversing their contents called an iterator. An iterator is best visualized as a pointer to an element in the list with a set of overloaded operators that provide extra functionality.

Overloaded iterator operators:

• Operator* dereferencing an iterator gives the element that the item is pointing to
• Operator++ advances the iterator to point to the next element
• Operator== & != gives basic comparison for two iterators to see if they point to the same element.
• Operator= assign to a new location

Each container has functions that return an iterator.

• begin() returns an iterator at the beginning of the container
• end() returns an iterator at the start of the container
• cbegin() returns a const iterator at the start of the container
• cend() returns a const iterator at the end of the container

Iterators are members of an STL container. For example to get an iterator for a specific type of list:

std::map<int, std::string>::const_iterator mapIt = myMap.cbegin(); 

An std::vector is a sequence container dynamic array that can grow to add to more elements.

An std::deque is double ended array that can grow from each end.

An std::pair is an object that holds a pair of objects.

// pair::pair example
#include <utility>      // std::pair, std::make_pair
#include <string>       // std::string
#include <iostream>     // std::cout
 
int main () {
  std::pair <std::string,double> product1;                     // default constructor
  std::pair <std::string,double> product2 ("tomatoes",2.30);   // value init
  std::pair <std::string,double> product3 (product2);          // copy constructor
 
  product1 = std::make_pair(std::string("lightbulbs"),0.99);   // using make_pair (move)
 
  product2.first = "shoes";                  // the type of first is string
  product2.second = 39.90;                   // the type of second is double
 
  std::cout << "The price of " << product1.first << " is $" << product1.second << '\n';
  std::cout << "The price of " << product2.first << " is $" << product2.second << '\n';
  std::cout << "The price of " << product3.first << " is $" << product3.second << '\n';
  return 0;
}

An std::list is a sequence container where each element contains a pointer to the next and previous element. You can't randomly access elements, you have to “walk the list”. But inserting elements is very fast if you know where to insert them.

An std::set is an ordered list of unique elements that get automatically sorted as we insert them.

An std::multiset is an ordered list of elements that can contain duplicate data which is automatically sorted as we insert them.

An std::map is an associated array which is a map, symbol table or dictionary that has a collection of key value pairs such that a key only shows up once.

Data pairs must be inserted into a map, and while you do this they are automatically sorted. You can make pairs with the std::make_pair(x,y) helper function.

std::map<int, std::string> myMap;
myMap.insert(std::make_pair(1, "mango"));

For every new there must be a delete. Use the following valgrind command to profile for memory leaks link.

valgrind --tool=memcheck --leak-check=yes name_of_exec

Lambda functions are:

• functions without a name
• define their functionality right in place
• can be copied like data

Lambda functions should be precise and self explaining.

The syntax is as follows:

• [] : captures the used variables per copy of per reference
• () : is required for parameters
• → : is required for a return value
• {} : may include expressions and statements

C++ 11 introduced the range-based for statement ²⁾ and takes the form:

for ( for-range-declaration : expression ) statement

Example:

int array[5] = { 1, 2, 3, 4, 5 };
for (int& x : array)
    x *= 2;

There are lots of options for debugging. I make extensive use of DDD with ROS which helped a lot. gdbgui is an interesting web based front end, but i tried it for 5 mins and ran into issues with it debugging a simple program.

Debugging in GDB is not that bad! It is also really useful when looking at simple stuff for learning stuff.

This is a really nice intro link.

This is a really nice video on gdbtui (which is the text user input) mode link.

To debug in GDB you need to compile a program with a debug with a -g option.

For macros see the following link.

mutable permits modification of the class member declared mutable even if the containing object is declared const.

int main()
{
    int n1 = 0;           // non-const object
    const int n2 = 0;     // const object
    int const n3 = 0;     // const object (same as n2)
    volatile int n4 = 0;  // volatile object
    const struct
    {
        int n1;
        mutable int n2;
    } x = {0, 0};      // const object with mutable member
 
    n1 = 1; // ok, modifiable object
//  n2 = 2; // error: non-modifiable object
    n4 = 3; // ok, treated as a side-effect
//  x.n1 = 4; // error: member of a const object is const
    x.n2 = 4; // ok, mutable member of a const object isn't const
 
    const int& r1 = n1; // reference to const bound to non-const object
//  r1 = 2; // error: attempt to modify through reference to const
    const_cast<int&>(r1) = 2; // ok, modifies non-const object n1
 
    const int& r2 = n2; // reference to const bound to const object
//  r2 = 2; // error: attempt to modify through reference to const
//  const_cast<int&>(r2) = 2; // undefined behavior: attempt to modify const object n2
}

Output:

# typical machine code produced on an x86_64 platform
# (only the code that contributes to observable side-effects is emitted)
main:
    movl    $0, -4(%rsp) # volatile int n4 = 0;
    movl    $3, -4(%rsp) # n4 = 3;
    xorl    %eax, %eax   # return 0 (implicit)
    ret