C Reference - Data Types Keywords

Basic Types

Type

Group

Type

Name

Size

[bits]

Hex

Range

  void 0

-

Characters signed char

char

8 0x80..0x7F
unsigned char 8 0x00..0xFF
Integers signed short int

short int

short

16 0x8000..0x7FFF
unsigned short int

unsigned short

16 0x0000..0xFFFF
signed int

int

32* 0x80000000..

0x7FFFFFFF

enum 32* 0x80000000..

0x7FFFFFFF

unsigned int

unsigned

32* 0x00000000..

0xFFFFFFFF

signed long int

long int

long

32 0x80000000..

0x7FFFFFFF

unsigned long int

unsigned long 

32 0x00000000..

0xFFFFFFFF

long long int

long long

64 0x8000000000000000..

0x7FFFFFFFFFFFFFFF

unsigned long long int

unsigned long long 

64 0x0000000000000000..

0xFFFFFFFFFFFFFFFF

Floating

Point

float 32* 1.17549e-38..

3.40282e+38

double 64* 2.2250e-308..

1.7976e+308

long double 64* 2.2250e-308..

1.7976e+308

* machine dependent

Derived Types

Name Declaration Syntax Description
Pointer

type *name;

Contains address of another variable
Array type name[size]; Set of variables of the same type
Structure struct tag {...} name; Set of variables of different types
Union union tag {...} name; Set of variables of different types that are allocated on the same memory

 

Type Specifiers and Qualifiers

Name Syntax Description
typedef typedef old_type new_type; Type definition
extern extern type name; External variable declaration
static static type name; Static variable has a lifetime until the end of program and a local scope
const const type name=value; Constant variable - can't be changed
auto auto type name; Declare local variable inside function.

Can be omitted from the code.

register register type name; Declare local variable inside function. Suggests compiler to keep variable in CPU register. Used for optimization.
volatile volatile type name; Avoid compiler optimization, used when can be changed externally.

i.e: I/O addressed variable.

 

 


void

Syntax:

void

Size:
  • 0 bits
  • 0 bytes
Description:
Void type
Example1:

void *p;

p = (void *)(&x);

Example2:

void my_func(int x)

{

   :

 

   /* no return value */

}

 


char

Syntax:

char variable name;

Size:
  • 8 bits
  • 1 bytes
Range:
  • Dec:   -128..127

  • Hex:   0x80..0x7F

  • Const: CHAR_MIN..CHAR_MAX

Description:
Signed character
Examples:

char c;

char c=32;

char c='a';

char *msg="Hello there";

char msg[]="Hello there";

 


signed char

Syntax:

signed char variable name;

Size:
  • 8 bits
  • 1 bytes
Range:
  • Dec:   -128..127

  • Hex:   0x80..0x7F

  • Const: SCHAR_MIN..SCHAR_MAX

Description:
Signed character.

Same as char.

Examples:

signed char c;

signed char c=-100;

signed char c='a';

signed char *msg="Hello there";

signed char msg[]="Hello there";

 


unsigned char

Syntax:

unsigned char variable name;

Size:
  • 8 bits
  • 1 bytes
Range:
  • Dec:   0..255

  • Hex:   0..0xFF

  • Const: 0..UCHAR_MAX

Description:
Unsigned character.
Examples:

unsigned char c;

unsigned char c=200;

unsigned char c='a';

 


short

Syntax:

short variable name;

Size:
  • 16 bits
  • 2 bytes
Range:
  • Dec:   -32768..32767

  • Hex:   0x8000..0x7FFF

  • Const: SHRT_MIN..SHRT_MAX

Description:
Signed short integer
Examples:

short c;

short c=-20000;

short c=20000;

 


unsigned short

Syntax:

unsigned short variable name;

Size:
  • 16 bits
  • 2 bytes
Range:
  • Dec:   0..65535

  • Hex:   0..0xFFFF

  • Const: 0..USHRT_MAX

Description:
Unsigned short integer.
Examples:

unsigned short c;

unsigned short c=40000;

 


int

Syntax:

int variable name;

Size:
  • 32 bits (machine dependent)
  • 4 bytes
Range:
  • Dec:   -2147483648..2147483647

  • Hex:   80000000..0x7FFFFFFF

  • Const: INT_MIN..INT_MAX

Description:
Signed integer.
Examples:

int c;

int c=-200000;

int c=200000;

 


enum

Syntax:

enum name {

   name1 [= number1],

   name2 [= number2],

   name3 [= number3],

   :

};  

Size:
  • 32 bits
  • 4 bytes
Range:
  • Dec:   -2147483648..2147483647

  • Hex:   80000000..0x7FFFFFFF

  • Const: INT_MIN..INT_MAX

Description:
Enumeration constant list of signed integers.
Examples:

enum subject {

   MATH        = 1,

   PHYSICS     = 2,

   CHEMISTRY   = 3,

   PROGRAMMING = 4,

   ELECTRONICS = 9

};

 


unsigned int

Syntax:

unsigned int variable name;

Size:
  • 32 bits (machine dependent)
  • 4 bytes
Range:
  • Dec:   0..4294967295

  • Hex:   0..0xFFFFFFFF

  • Const: 0..UINT_MAX

Description:
Unsigned integer.
Examples:

unsigned int c;

unsigned int c=200000U;

 


long

Syntax:

long variable name;

Size:
  • 32 bits
  • 4 bytes
Range:
  • Dec:   -2147483648..2147483647

  • Hex:   80000000..0x7FFFFFFF

  • Const: LONG_MIN..LONG_MAX

Description:
Signed long integer.
Examples:

long c;

long c=-200000L;

long c=200000L;

 


unsigned long

Syntax:

unsigned long variable name;

Size:
  • 32 bits
  • 4 bytes
Range:
  • Dec:   0..4294967295

  • Hex:   0..0xFFFFFFFF

  • Const: 0..ULONG_MAX

Description:
Unsigned long integer.
Examples:

unsigned long c;

unsigned long c=200000UL;


long long

Syntax:

long long variable name;

Size:
  • 64 bits
  • 8 bytes
Range:
  • Dec:   9223372036854775808..

           9223372036854775807

  • Hex:   0x8000000000000000..

           0x7FFFFFFFFFFFFFFF

  • Const: LLONG_MIN..LLONG_MAX

Description:
long long integer.
Examples:

long long c;

long long c=200000LL;


unsigned long long

Syntax:

unsigned long long variable name;

Size:
  • 64 bits
  • 8 bytes
Range:
  • Dec:   0..18446744073709551615

  • Hex:   0..0xFFFFFFFFFFFFFFFF

  • Const: 0..ULLONG_MAX

Description:
Unsigned long long integer.
Examples:

unsigned long long c;

unsigned long long c=200000ULL;

 


float

Syntax:

float variable name;

Size:
  • 32 bits
  • 4 bytes
Range:
  • Dec:   1.17549e-38..

           3.40282e+38

  • Const: FLT_MIN..FLT_MAX

Description:
Single precision floating point.
Examples:

float c;

float c=200.8F;

float c=-2e-8F;

 


double

Syntax:

double variable name;

Size:
  • 64 bits
  • 8 bytes
Range:
  • Dec:   2.2250e-308..

           1.7976e+308

  • Const: DBL_MIN..DBL_MAX

Description:
Double precision floating point.
Examples:

unsigned char c;

unsigned char c=200.8;

unsigned char c=-2e-8;

 


long double

Syntax:

long double variable name;

Size:
  • 64 bits
  • 8 bytes
Range:
  • Dec:   2.2250e-308..

           1.7976e+308

  • Const: LDBL_MIN..LDBL_MAX

Description:
Long double precision floating point.
Examples:

unsigned char c;

unsigned char c=200.8L;

unsigned char c=-2e-8L;

 


Pointer

Syntax:

type *name;

type (*func_ptr)(type1, type2,..);

Description:
Contains the memory address of another variable
Example1:

int x=10;

int *px;

 

/* px points to x -

   px contains the address of x */

px = (int *)(&x);

 

/* x now equal to 20 */

*px = 20;

Example2:

int square(int x)

{

   return x*x;

}

 

int main(void)

{

   /* function pointer declaration */

   int (*pfunc)(int) = square;

 

   /* call function -> y=100 */

   int y = (*pfunc)(10);

}

 


Array

Syntax:

type name[size];

type name[size1][size2];

Description:
Contains a set of variables of the same type
Example1:

int x[10];

int y[10][20];

int z[5]={10,20,30,40,50};

char s[]="Hello";

 

int i,j;

 

/* reset x array */

for(i=0; i<10; i++) {

   x[i] = 0;

   for(j=0; j<10; j++) {

      y[i][j] = 0;

   }

}

 

/*  */

*px = 20;

Example2:

int square(int x)

{

   return x*x;

}

 

int main(void)

{

   /* function pointer declaration */

   int (*pfunc)(int) = square;

 

   /* call function -> y=100 */

   int y = (*pfunc)(10);

}

 


Structure

Syntax:

struct tag {

   type1 member1;

   type2 member2;

   ...

} name;

Description:
Contains a set of variables of different types
Example1:

struct time {

   int h;

   int m;

};

 

struct time *pt;

struct time dt;

struct time t1 = {8,0};

struct time t2 = {16,0};

 

dt.h = t2.h - t1.h;

dt.m = t2.m - t1.m;

if(dt.m < 0) {

   dt.m += 60;

   dt.h -= 1;

}

Example2 - bit fields:

struct reg {

   unsigned int in       : 3;

   unsigned int out      : 4;

   unsigned int reserved : 9;

};

int input;

int output;

 

struct reg r=0; // sets all bits to 0

input = r.in;

output = 3;

r.out = output;

 


Union

Syntax:

union tag {

   type1 member1;

   type2 member2;

   ...

} name;

Description:
Contains a set of variables, that are allocated on the same memory
Example:

union data {

   unsigned long num;

   char name[4];

}

union data d1.name="abc";

union data d2.num =0x00434241;

/* now d1 is equal to d2 */

 


typedef

Syntax:

typedef old_type new_type;

Description:
New type definition
Example:

typedef unsigned char Byte

typedef unsigned int Word

typedef struct time {

   char h;

   char m;

} Time;

 

Byte c=255;

Word x;

Time t;

 


extern

Syntax:

extern type name;

Description:
External variable  declaration, used in other files to broaden the variable scope to other files. The external declaration is usually written in header file.
Example:
See Program Structure

 


static

Syntax:

static type name;

static type function(type arg1,...)

Description:
Static variables are freed only when program ends, even when defined inside a function.

Static variables have local file scope for global variables, and local function scope for local variables.

Static functions have local file scope and are not visible outside the file.

Example:

// external static variable

static int a;

 

void myfunc()

{

   // local static variable

   static int x=10;

 

   x = x+1; /* =10,11,12,...         */

            /* for each function call*/

}

 


const

Syntax:

const type name=value;

Description:
Constant variable - can't be changed
Example:

const int linesnum=100;

linenum = 0; /* error! */

 


auto

Syntax:

auto type name;

Description:
Declare local variable inside function. Can be omitted from the code.
Example:

void myfunc()

{

   auto int x;

   ...

}

 


register

Syntax:

register type name;

Description:
Declare local variable inside function. Suggests compiler to keep variable in CPU register. Used for optimization.
Example:

void myfunc()

{

   register int x;

   ...

}

 


volatile

Syntax:

volatile type name;

Description:
Avoid compiler optimization, used when can be changed externally (i.e: I/O addressed variable).
Example:

volatile unsigned short data;

 

Write how to improve this page

C REFERENCE
RAPID TABLES