Embedded System

Inline functions property says whenever it will called, it will copy the complete definition of that function. Recursive function declared as inline creates the burden on the compilers execution.

The size of the stack may/may not be overflow if the function size is big.

constructors top-down, destructors bottom-up.

eg:

in parent's constructor

in child's constructor

in grandchild's constructor

in grandchild's destructor

in child's destructor

in parent's destructor

yes,

void foo(void)

{

unsigned int a = 6;

int b = -20;

(a+b > 6) ? puts("> 6") :

puts("<=6");

}

Here output would give you "> 6". The reason for this is that expressions involving signed and unsigned types have all operands

promoted to unsigned types

5 level types are as under:

single: B derived from A

multilevel:C derived from B and B derived from A

multiple:C derived from A and B

Hierarchical:B derived from A and C derived from A

hybrid:combination of above types

1) Volatile:

A variable should be declared volatile whenever its value could change unexpectedly. In practice, only three types of variables could change:

► Memory-mapped peripheral registers

► Global variables modified by an interrupt service routine

► Global variables within a multi-threaded application

2) Constant:

The addition of a 'const' qualifier indicates that the (relevant part of the) program may not modify the

variable.

1) Volatile:

A variable should be declared volatile whenever its value could change unexpectedly. In practice, only three types of variables could change:

► Memory-mapped peripheral registers

► Global variables modified by an interrupt service routine

► Global variables within a multi-threaded application

2) Constant:

The addition of a 'const' qualifier indicates that the (relevant part of the) program may not modify the

variable.

interrupt latency is the time required to return from the interrupt service routine after tackling a particular interrupt. We can reduce it by writing smaller ISR routines.

Because in C when you say the name of the array it means the address of the first element.

example :

int a[];

func (a);

int func(int a[]);

In this when you call the function by passing the argument a actually &a[0](address of first element) gets passed. Hence it is impossible to pass by value in C.

Advantage:

Macros and Inline functions are efficient than calling a normal function. The times spend in calling the function is saved in case of macros and inline functions as these are included directly into the code.

Disadvantage:

Macros and inline functions increased the size of executable code.

Static variables can only be accesed in the files were they are declared.

Static variable within the scope of a function store it's values in consecutive calls of that function.

Static functions can only be caled within the file they are defined.

object based languages doesnt support Inheritance where as object oriented supports. c# is a object oriented language because it supports inheritance and asp.net is not a langugae it is a technology

If the language supports ony 3 features i;e (data encapsulation,data abstraction $ polymorphism).then it is said to be object based programming language. If the language supports all the 4 features i;e(encapsulatio,abstraction,polymorphism $ also inheritance )..then it is said to be object oriented programming language.

Interrupt latency refers to the amount of time between when an interrupt is triggered and when the interrupt is seen by software.

Embedded system can include RTOS and cannot include also. it depends on the requirement. if the system needs to serve only event sequencially, there is no need of RTOS. If the system demands the parallel execution of events then we need RTOS.

You can define structure bit field members with Dot operators.

EXAMPLE:

#include <stdio.h>

int main()

{

Struct bit_field

{

Int x.4; // it allocates only 4 bits to x

Char C.6; // it allocates only 6 bits to C;

};

return 0;

}

#include<stdlib.h>

#include<stdio.h>

int main()

{

int n = 6789;

char p[20];

itoa(n,s,10);

printf("n=%d,s=%s",n,s);

return 0;

}

Four types of storage classes are there in c.

1.Auto

2.Register

3.Static

4.Extern or Global

Pointer use's to reference to value a into int a=10 to memory add this value and 10 is add p value added this data in memory location for p............for reference key is a

Const and volatile keywords should not be used together because both are opposite in nature.

A variable is declared as "const" means it's value is not able to be changed but if it is declared as "Volatile" then it is not under control.

Yes structures can be passed to functions by value. Though passing by value has two disadvantages :

1) The charges by the calling function are not reflected

2) Its slower than the pass by reference function call.