C Programming

Register variables are stored in register of microprocessor/micro-controller. The read/write access to register variable is the fastest because CPU never need any memory BUS operation to access these variable.

Auto variable are stored in stack thus access are much slower. Auto variable can be converted to register by using register keyword before it. It has platform specific limitation. Register variable will work only if free registers are available to hold the variable for a function scope. In case of Microprocessor or microcontrollers having very less number of general purpose registers will never take register variable even if we declare it as register.

// stack to contain content

Stack sourceStack = new Stack();

// ... fill sourceStack with content

// stack to contain reversed content

Stack targetStack = new Stack();

while (!sourceStack.empty())

{

targetStack.push(sourceStack.pop());

}

// targetStack contains the reversed content of sourceStack

It is a spectrum. I know this because i am currently in physical science class and we just discussed it. Unless my teacher and book are wrong, this is right.

There are four types of storage class or variable in c.

1) auto storage class.

2) register storage class.

3) static storage class.

4) external storage class.

CLS
FOR n = 2 TO 100
FOR k = 2 TO n / 2
flag = 0
r = n MOD k
IF r = 0 THEN
flag = 1
EXIT FOR
END IF
NEXT k
IF flag = 0 THEN PRINT n,
NEXT n
END

Every digit in a binary number corresponds to power of two. So 0001 0101 is equal to 0*2^7 + 0*2^6 + 0*2^5 + 1*2^4 + 0*2^3 + 1*2^2 + 0*2^1 + 1*2^0, which equals 0+0+0+16+0+4+0+1, which equals 21.

Descriptions are best represented using a character array (string) data type.

Arrays are the most efficient data structure. Memory is allocated to the entire array as a single operation and the total memory consumed is equal to the product of the element size and the number of elements (all elements being of equal size, in bytes). This means that any element in the array can be accessed using simple pointer arithmetic from the start of the array, with the first element at offset 0. All high level languages hide the pointer arithmetic behind an array suffix operator, such that element [5] will be found 5 * sizeof (element) bytes from the start address of the array (the address where element [0] resides). Multi-dimensional arrays are implemented as an array of arrays, such that a two-dimensional array is a one-dimensional array where every element is itself a one-dimensional array. These can be thought of as being a table of rows and columns where the first dimension access a one-dimensional row array, and the second dimension accesses the column within that row. A three-dimensional array can then be thought of as being an array of tables or a cuboid (a stack of tables). A four-dimensional array can therefore be thought of as being an array of cuboids, a table of tables, or a cuboid of arrays. By imagining arrays in this manner it becomes much simpler to imagine arrays with more than 3 dimensions.

By contrast, a list or a tree structure is less efficient because every element requires at least one additional field to maintain the link from that element to another element, thus defining the structure. You also need to maintain an additional field to refer to the first element in the structure. If you have a structure that can dramatically vary in size, lists may be more efficient because there is no need to reallocate the entire structure; you simply allocate and deallocate memory for individual elements and update the links between elements to maintain the structure. However, you lose constant-time random access because you have to traverse the links in the structure to locate an individual element and the additional level of indirection means it will be slower than an array. However, reallocating an array often means copying the array to new memory. One way to minimise reallocations is to reserve more memory than you actually need, thus allowing you to add new elements more quickly at the cost of some memory. You only need to reallocate when you run out of reserve. You can also minimise the cost of reallocation by storing pointers rather than objects in your array. This adds an extra level of indirection, but speeds up the reallocation process by only copying pointers rather than objects being pointed.

The following function will return the GCD or LCM of two arguments (x and y) depending on the value of the fct argument (GCD or LCM).

enum FUNC {GCD, LCM};

int gcd_or_lcm(FUNC fct, int x, int y) {

int result = 0;

switch (fct) {

case (GCD): result = gcd (x, y); break;

case (LCM): result = lcm (x, y); break;

}

return result;

}

No. There is no default return type for functions, it must be explicitly specified in both the function declaration and in the definition. To specify no return value, return void. To return a variant type, return void* (pointer to void). Otherwise return the exact type.

#include<stdio.h> main() { char key; clrscr(); printf("Enter the key"); scanf("\n %c",& key); if (key>='A' key<='Z' )&&(key>='a' key<='z') { printf("%c is an character \n",key); } else { printf("%c is not character",key); } getch(); }

int RevNum( int num )

{

const int base = 10;

int result = 0;

int remain = 0;

do

{

remain = num % base;

result *= base;

result += remain;

} while( num /= base);

return( result );

}

Advantages:

1. You can use one name for similar objects and save then with the same name but different indexes.

2. Arrays are very useful when you are working with sequances of the same kind of data (similar to the first point but has a different meaning).

3. Arrays use reference type and so.

Disadvantages:

1. Sometimes it's not easy to operate with many index arrays.

2. C environment doesn't have checking machism for array sizes.

3. An array uses reference mechanism to work with memory which can cause unstable behaviour of operating system (unless special methods were created to prevent it) and often even "blus screen" and so on. store the many characters or vales in a single variable.

The C++ string classes are derived from the std::basic_string<T> template class, where T is a character type. The standard provides the two most common string types, std::string (std::basic_string<char>) and std::wstring (std::basic_string<wchar_t>). The former is used for ASCII strings (which includes UTF-8 strings) while the latter is used for wide-character strings, particularly UNICODE strings.

All standard library strings are represented by an array of some character type (such as char or wchar_t) however, unlike an ordinary array, the individual character elements cannot be re-ordered other by overwriting each character. If you simply need an array of characters that can be re-ordered then use a std::vector<char> or std::vector<wchar_t> rather than a string.

The standard library strings include a rich set of methods, operations and algorithms that are commonly used with strings, such as std::string::find() to locate a character within a string, std::string::substr() to extract a substring from a string, and operator+= to concatenate one string onto another. Most implementations include the short string optimisation so that short strings (up to around 14 characters or so) may be stored in local memory rather than on the heap. Many strings tend to be short so this can provide enormous performance benefits with little cost in terms of memory.

Read the part in your programming manual/text book about recursion.

The short answer while easy does not tell you anything about the power or dangers of recursion. It is the power and dangers of recursion that is important because once understood you can use recursion to good effect without running out of stack space.

I don't really know that is a good question to ask a teacher or someone.

A sorting technique that sequences a list by continuously dividing the list into two parts and moving the lower items to one side and the higher items to the other. It starts by picking one item in the entire list to serve as a pivot point. The pivot could be the first item or a randomly chosen one. All items that compare lower than the pivot are moved to the left of the pivot; all equal or higher items are moved to the right. It then picks a pivot for the left side and moves those items to left and right of the pivot and continues the pivot picking and dividing until there is only one item left in the group. It then proceeds to the right side and performs the same operation again

void main()

{

int n,old=0,curr=1,new=0;

clrscr();

printf("enter the total number of terms up to which you want to print the Fibonacci series");

scanf("%d",&n);

printf("%d",old);

printf("\n%d",curr);

for(i=1;i<=n;i++)

{

new=old+curr;

old=curr;

curr=new;

printf("\n%d",new);

}

getch();

}

The #define preprocessor directive is severely overused in my opinion.

Often, you will see programmers write something like this:

# define MAX(a, b) (((a) > (b))? (a) : (b))

However doing so is rather dangerous, because the preprocessor replaces things textually.

This means that if you pass in a call to a function, it may happen twice, for example:

MAX(++i, j) will be expanded to

(((++i) > (j))? (++i) : (j))

which is bad.

A much safer (and more common) example is that people will use #define to create a constant variable:

#define MYCONST 10

This too can cause problems if another file depends on the constant and certain other conditions are met.

A safer alternative is to declare a const variable.

The one advantage of using #define for literal constants is that the number will not be stored in memory attached to an object like a const variable will.

C is a weakly typed procedural programming language. For object oriented programming languages near C, you can look at ooc ( http://ooc-lang.org/ ), C++, D, and Java.

it is a random splitting of atoms made of protons and neutrons and electrons if they split the universe willexplode.