Storage Classes in C (C Interview Question - 2)

-
What is Storage Class:

Storage class determines the scope and lifetime of the variable

What is Scope?

 Scope or visibility tells you about the part of the program that can access the variable.

What is lifetime?

 Each variable in C is assigned some physical location where it can store some value. The lifetime defines how long the value will be present in that particular location. A variable may have local lifetime or global lifetime. A variable that has global lifetime,its value will be persisted throughout the program, whereas a variable with local lifetime,value will persist in the block which it is defined.

There are four storage classes in C

1. auto
2. register
3. static
4. extern


1. auto:

  • Default storage class. If we don't specify any storage class  while defining the variable then by default storage class will be taken as auto
  • Scope: Auto can only be used within functions. If you try to specify a global variable with auto storage class then you will get a compile time error
  • Lifetime: Within the function in which it is defined. Created when the function is called and destroyed when the function terminates.
  • Initial Value: Garbage
  • Storage: stack
2. register:

Register is similar to stack , except the values are stored in register instead of storing in stack
    • scope: similar to auto variables there scope is local to the block
    • Lifetime: Storage is allocated when the function is called and destroyed when the function terminates
    • Initial Value: Garbage
    • Storage: Registers
    • Note: You have to use registers only when a variable is repeatedly used for example counters. We cannot apply unary operator (&) to the register, as it does not have memory allocated to it.
3. static:

  • scope: In the function it is defined locally, else within the file if defined global
  • Lifetime: Value of the static variable persists till the end of the program
  • Initial Value; 0
  • Storage: Initialized variables goes into BSS (Block started by symbol),uninitialized variables,i.e., the variables initialized by compiler will be stored in DATA section
  • Note: Static variables are initialized only once.
4. extern:

  • scope: Throughout the program, visible to all the files
  • Lifetime: End of the program
  • Initial Value: Not initialized, it will be pointing to already defined variable.
  • Storage: Initialized variables goes into BSS, uninitialized variables goes into DATA section

Comments

Post a Comment

Popular posts from this blog

bb.utils.contains yocto

-
Image
bb.utils.contains  is most commonly used function in Yocto. grep in poky directory returned with 696 count. $ grep -nr 'bb.utils.contains' poky/ | wc -l 696 It's definition is present in 'poky/bitbake/lib/bb/utils.py' file This function returns third argument if the second argument is subset of the first argument else returns fourth argument Let's take an example to understand this. You can see from the above screenshot, when the second argument is a subset of first argument, "present" was returned, else "notpresent" was returned We can also use bb.utils.contains inside if loop. This we can use inside a recipe. if ${@bb.utils.contains('SOMEFLAG','NEWVALUE3','true','false',d)}; then     FOO = 'HELLO' fi
Read more

Difference between RDEPENDS and DEPENDS in Yocto

-
We normally observe these two (RDEPENDS and DEPENDS) whenever we open any recipe. What should we choose when we write our own recipe. DEPENDS -> Build Time Dependency RDEPENDS -> Run Time Dependency DEPENDS: When a recipe 'A' is DEPENDS on recipe 'B'. In this case, Bitbake first builds recipe 'B' and then recipe 'A' E.g. You need 'dbus' to be built before 'wpa_supplicant'. RDEPENDS: When a recipe 'A' is RDEPENDS on recipe 'B'. In this case, Bitbake deploys 'B' on the target system when it deploys 'A'.  E.g. 'perf' RDEPENDS on 'bash' In other words, DEPENDS are those set of packages that should be available while building package, whereas RDEPENDS are set of packages that should be available during execution of the program.
Read more

make config vs oldconfig vs defconfig vs menuconfig vs savedefconfig

-
Image
Building the Linux Kernel is a two-step process: Configuring the Kernel options Building the Kernel with those options. There are many methods available for configuring the kernel. make config: Text-based Configuration.  Options are prompted one after another. All options need to be answered Access to former options is not possible make menuconfig: Menu-driven user interface Allows to navigate forwards and backward directly between features Allows to load and save files with filenames different from ".config" Provides search feature It uses ncurses library for GUI. If the ncurses library is not installed, make menuconfig option fails. To install ncurses library on Ubuntu: sudo apt-get install libncurses5-dev make defconfig: Creates a ".config" file with default options from the ARCH supplied defconfig Configurations are generally stored in the directory: arch/$(ARCH)/configs $ ls arch/x86/configs/ i386_defconfi
Read more