1) void *realloc(void *ptr, size_t size);
-> realloc changes the size of the allocated memory pointed to by the argument ptr
-> newly allocated memory will be uninitialized
-> you can pass a NULL ptr safely to realloc
-> realloc may move your data to a new pointer and free the memory at the old pointer. It will return the new pointer, or the old pointer if the data is not moved.
2) Calloc
-> allocates a region of memory large enough to hold “n elements” of “size” bytes each. Also initializes contents of memory to zeroes.
-> void *calloc (number_of_blocks, size_of_each_block_in_bytes);
-> The allocated region is initialized to zero.
-> void pointer (void *). If the allocation succeeds, a pointer to the block of memory is returned.
void *calloc(size_t nelements, size_t bytes);
Malloc:
-> allocates “size” bytes of memory.
-> void *malloc (size_in_bytes);
-> The contents of allocated memory are not changed. i.e., the memory contains unpredictable or garbage values. This presents a risk.
-> void pointer (void *). If the allocation succeeds, a pointer to the block of memory is returned.
void *malloc(size_t size);
3) In theory, which is faster, the call to strcpy or the call to memcpy?
#include <string.h>
#include <stdlib.h>
int main(){
char msg[12] = "Hello World";
char buffer1[12];
char buffer2[12];
strcpy(buffer1, msg);
memcpy(buffer2, msg, sizeof(msg));
return 0;
}
Answer:
memcpy should be faster because it does not need to check every byte for a NULL, it is copying a known size of data.
4)Variables declared outside of functions or with the static specifier are always initialized to zero. Therefore this program has deterministic behavior.
#include <stdlib.h>
#include <stdio.h>
int* ptrToData;
int main(){
if (!ptrToData){
ptrToData = (int*)malloc(sizeof(int) * 10);
printf("%p\n", ptrToData);
}
free(ptrToData);
return 0;
}
5) Fortunately, C/C++/Java makes this simple.
* To write numbers in octal, precede the value with a 0. Thus, 023 is 238 (which is 19 in base 10).
* To write numbers in hexadecimal, precede the value with a 0x or 0X. Thus, 0×23 is 2316 (which is 35 in base 10).
6)
How to Write a Negative Value
When you write 0×23, you might wonder how to negate it. Should you write the minus sign before the 0x, or after it? The answer is before. 0x indicates that the digits afterwards are written in hex. – is an operator, so it applies to a non-negative representation. Thus, you write -0×23. which is equivalent to -35
7) Structure Member Alignment, Padding and Data Packing
http://www.geeksforgeeks.org/structure-member-alignment-padding-and-data-packing/
8: C Bit Fields : http://msdn.microsoft.com/en-us/library/yszfawxh.aspx
struct-declarator:declarator
type-specifier declarator opt : constant-expression
The constant-expression specifies the width of the field in bits. The type-specifier for the declarator must be unsigned int, signed int, or int, and the constant-expression must be a nonnegative integer value. If the value is zero, the declaration has no declarator. Arrays of bit fields, pointers to bit fields, and functions returning bit fields are not allowed. The optional declarator names the bit field. Bit fields can only be declared as part of a structure. The address-of operator (&) cannot be applied to bit-field components.
Unnamed bit fields cannot be referenced, and their contents at run time are unpredictable. They can be used as “dummy” fields, for alignment purposes. An unnamed bit field whose width is specified as 0 guarantees that storage for the member following it in the struct-declaration-list begins on an int boundary.
Bit fields must also be long enough to contain the bit pattern. For example, these two statements are not legal:
short a:17; /* Illegal! */
int long y:33; /* Illegal! */
This example defines a two-dimensional array of structures named screen.
struct
{
unsigned short icon : 8;
unsigned short color : 4;
unsigned short underline : 1;
unsigned short blink : 1;
} screen[25][80];
7) C bit field storage question: stackoverflow.com/questions/21164939/unexpected-behaviour-of-bit-field-operator-in-c
8)
#include<stdio.h>
struct st
{
int x;
static int y;
};
int main()
{
printf("%d", sizeof(struct st));
return 0;
}
->In C, struct and union types cannot have static members. In C++, struct types are allowed to have static members, but union cannot have static members in C++ also.
9: A structure cannot contain a member of its own type because if this is allowed then it becomes impossible for compiler to know
sizeof such struct. Although a pointer of same type can be a member because pointers of all types are of same size and compiler cancalculate size of struct
10) Size of array can’t be constant
#include<stdio.h>
void main(){
int const SIZE=5;
int expr;
double value[SIZE]={2.0,4.0,6.0,8.0,10.0};
expr=1|2|3|4;
printf("%f",value[expr]);
}
Give compiler error
11) strlen(“nishant”) = 7
sizeof(“nishant”) = 8
strlen(“nishant “) = 8
sizeof(“nishant “) = 10
strlen(“nishantkumar”) = 7
sizeof(“nishant kumar”) = 16
12) Hexadecimal : 0X, \x,
Octate : 0 Followed by number less then 7 ex: 01001 = 513 , ‘\111′ = 73 here \ representing octate
#include<stdio.h>
#define WWW -1
enum {cat,rat};
void main(){
int Dhoni[]={2,'b',0x3,01001,'\x1d','\111',rat,WWW};
int i;
for(i=0;i<8;i++)
printf(" %d",Dhoni[i]);
}
1
2 98 3 513 29 73 1 -1
In c any character is starting with character ‘\’ represents octal number in character. As we know octal digits are: 0, 1, 2, 3, 4, 5, 6, and 7. So 8 is not an octal digit. Hence ‘\08’ is invalid octal character constant.
13)
1
#include<stdio.h>
void main(){
int a;
a= (3,4,5);
printf("%d",a);
}
[/sourcecode ]
a= 5
1
#include<stdio.h>
void main(){
int a;
a= 3,4,5;
printf("%d",a);
}
a=3
14) What will be output if you will compile and execute the following c code?
void main(){
char c=125;
c=c+10;
printf("%d",c);
}
15:
#include "stdio.h"
#include "string.h"
void main(){
char *str=NULL;
strcpy(str,"cquestionbank");
printf("%s",str);
}
Note:
void strcpy(char *target, char *source){
while(*source)
{
*target = *source;
source++;
target++;
}
*target = '\0';}
***Note: In strcpy function target should not be character pointer.
16)
void main(){
int i=10;
static int x=i;
if(x==i)
printf("Equal");
else if(x>i)
printf("Greater than");
else
printf("Less than");
}
Output: Compile time error
Explanation:
static variables are load time entity while auto variables are run time entity. We can not initialize any load time variable by the run time variable.
In this example i is run time variable while x is load time variable.
17)
#include<stdio.h>
int main(){
printf("%c",*"abcde");
return 0;
}
18) Label of GOTO: scope is function block it is not visible outside of function.
19) Scope of variable
19)
#include<stdio.h>
int main(){
int i=0;
{
auto int a=20;
XYZ:;
printf("%d",a);
a++;
i++;
}
if (i<3)
goto xyz;
return 0;
}
Explanation: Variable a which declared inside inner block has scope only within that block. Ones program control comes out of that block variable will be dead. If with the help of goto statement we will go to inside that inner block in the printf statement complier will not known about variable a because it has been destroyed already. Hence complier will show an error message: undefined symbol a. But if you will write goto statement label before the declaration of variable then there is not any problem because variable a will again declared and initialize.
20) We cannot initialize extern variable locally i.e. within any block either at the time of declaration or separately. We can only initialize extern variable globally. For example:
(a)
#include <stdio.h>
int main(){
extern int i=10; //Try to initialize extern variable
//locally.
printf("%d",i);
return 0;
}
Output: Compilation error: Cannot initialize extern variable.
(b)
#include <stdio.h>
int main(){
extern int i; //Declaration of extern variable i.
int i=10; //Try to locally initialization of
//extern variable i.
printf("%d",i);
return 0;
}
Output: Compilation error: Multiple declaration of variable i.
#include <stdio.h>
extern int i;
int main(){
i=25; //Assignment statement
printf("%d",i);
return 0;
}
int i=10; //Initialization statement
Output: 25
21) Typedef is a storage class : http://itee.uq.edu.au/~comp2303/Leslie_C_ref/C/SYNTAX/typedef.html
