Fortsätt till huvudinnehåll

Embedded development questions part I

Let me just hit you with this. Check this code:


const char* aChar_p = "Hello"; // (1) (2)
bool aBoolean; // (3)


int main()
{
  int i = 0; // (4)
  bool flag = true; // (5)


  return 0;
}


Now answer this. Where in memory will (1) be stored? What about (2), and (3), and (4), and (5)?
This was another question I was faced with during my recent job interview. To be honest, I have never needed to care much about linker files and memory layout. In every project I have been in these things have already been set up long before I've entered the scene. With that said, I think it's still good knowledge to have, so let's go trough them one by one.

  1. Variables defined at this (top) level are called global. They are accessible from anywhere in the code and has a lifespan that stretches over the entire program execution. You would say it is a static variable. Since the variable is static, you might think that adding the static keyword won't make any difference. This is however not correct, adding the static keyword to the declaration will limit the scope to the same source file. In most systems an initialized modifiable static variable is placed in the read-write data area of the data segment.
  2. As for (1) this data will be placed in the data area. However, since it is declared const it will probably be placed in a read-only section.
  3. Here we have an unitialized static variable. These are all placed in a special section of the data segment called .bss and their values are typically set to zero.
  4. This integer is a local initialized variable or automatic variable. Automatic variables, initialized or not, are almost for sure placed on the stack.
  5. See 4. The type of an automatic variable does not matter. It will be placed on the stack.
The guy who interviewed me claimed that both (1) and (3) would end up in .bss and that only (2) would end up in the data section. I believe that he was wrong and that (1) will be placed in the data section as well. What do you think?

Stay tuned for part II - find the bug(s).




Kommentarer

Populära inlägg i den här bloggen

C# Enum as bit field

Bit field enum Whenever you wish to express combinations of properties of an object, bit fields are a good way to accomplish this. As a simple example, consider a file in the file system. It can be Readable , Writable , Hidden or a combination these. The different attributes can be defined as an enum : [Flags] public enum FileAttribute {   None      = 0b0000;   Readable  = 0b0001;   Writeable = 0b0010;   Hidden    = 0b0100; } To indicate that this enum is expected to be used as a bit field I have defined it with the FlagsAttribute . It is important to understand that the FlagsAttribute does nothing more than making some changes to how the ToString method of the enum works, making it possible to print out all flags. It does not introduce any validation or special treatment of the enum in any other way. I have defined the values of the different fields of the enum using binary representation, this should make it even more clear that this is a bit field and which bi

Codility tasks - Part I

I was recently faced with two codility tasks when applying for a job as an Embedded Software Engineer. For those of you who arn't familiar with Codility you can check out their website here:  www.codility.com Task one - Dominator The first task was called Dominator. The goal was to, given a std::vector of integers, find an integer that occurs in more than half of the positions in the vector. If no dominator was found -1 should be returned. My approach was to loop through the vector from the first to the last element, using a std::map to count the number of occurences of each integer. If the count ever reached above half the size of the vector I stopped and returned that integer and if I reached the end without finding a dominator I returned -1. So was that a good approach? Well, the reviewer at the company rated the solution as 'pretty ok'. His preferred solution was store the first integer in the array and set a counter to 1. Then loop through the remaining i