# Types of Literals in C/C++ with Examples

• Last Updated : 30 Sep, 2019

The values assigned to each constant variables are referred to as the literals. Generally, both terms, constants and literals are used interchangeably. For eg, â€œconst int = 5;â€œ, is a constant expression and the value 5 is referred to as constant integer literal. There are four types of literals in C and five types of literals in C++.

The literals of C/C++ are divided accordingly:

1. Integer Literals: These are used to represent and store the integer values. Integer literals are expressed in two types i.e.,
1. Prefixes: The Prefix of the integer literal indicates the base in which it is to be read.
For example:
```0x10 = 16

Because 0x prefix represents a HexaDecimal base.
So 10 in HexaDecimal is 16 in Decimal.
Hence the value 16.
```

There are basically represent in four types.

1. Decimal-literal(base 10): A non-zero decimal digit followed by zero or more decimal digits(0, 1, 2, 3, 4, 5, 6, 7, 8, 9).

For example:

```56, 78
```
2. Octal-literal(base 8): a 0 followed by zero or more octal digits(0, 1, 2, 3, 4, 5, 6, 7).

For example:

```045, 076, 06210
```
3. Hex-literal(base 16): 0x or 0X followed by one or more hexadecimal digits(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, a, A, b, B, c, C, d, D, e, E, f, F).

For example:

```0x23A, 0Xb4C, 0xFEA
```
4. Binary-literal(base 2): 0b or 0B followed by one or more binary digits(0, 1).

For example:

```0b101, 0B111
```
2. Suffixes: The Prefix of the integer literal indicates the type in which it is to be read.

For example:

```12345678901234LL
indicates a long long integer value 12345678901234
because of the suffix LL
```

These are represented in many ways according to their data types.

1. int: No suffix is required because integer constant is by default assigned as an int data type.
2. unsigned int: character u or U at the end of an integer constant.
3. long int: character l or L at the end of an integer constant.
4. unsigned long int: character ul or UL at the end of an integer constant.
5. long long int: character ll or LL at the end of an integer constant.
6. unsigned long long int: character ull or ULL at the end of integer constant.

Example:

## C

 `#include `` ` `int` `main()``{`` ` `    ``// constant integer literal``    ``const` `int` `intVal = 10;`` ` `    ``printf``(``"Integer Literal:%d \n"``,``           ``intVal);``    ``return` `0;``}`

## C++

 `#include ``using` `namespace` `std;`` ` `int` `main()``{``    ``// constant integer literal``    ``const` `int` `intVal = 10;``    ``cout << ``"Integer Literal: "``         ``<< intVal << ``"\n"``;`` ` `    ``return` `0;``}`
Output:

```Integer Literal:10
```
2. Floating-Point Literals: These are used to represent and store real numbers. The real number has an integer part, real part, fractional part and an exponential part. The floating-point literals can be stored either in decimal form or exponential form. While representing the floating-point decimals one must keep two things in mind to produce valid literals:
• In the decimal form, one must include the decimal point, exponent part or both, otherwise, it will lead to an error.
• In the exponential form, one must include the integer part, fractional part or both, otherwise, it will lead to an error.

Few floating-point literal representations are shown below:

Valid Floating Literals:

```10.125
1.215-10L
10.5E-3
```

Invalid Floating Literals:

```123E
1250f
0.e879
```

Example:

## C

 `#include `` ` `int` `main()``{``    ``// constant float literal``    ``const` `float` `floatVal = 4.14;`` ` `    ``printf``(``"Floating point literal: %.2f\n"``,``           ``floatVal);``    ``return` `0;``}`

## C++

 `#include ``using` `namespace` `std;`` ` `int` `main()``{``    ``// Real literal``    ``const` `float` `floatVal = 4.14;`` ` `    ``cout << ``"Floating-point literal: "``         ``<< floatVal << ``"\n"``;``    ``return` `0;``}`
Output:
```Floating point literal: 4.14
```
3. Character Literal: This refers to the literals that are used to store a single character within a single quote. To store multiple characters, one needs to use a character array. Storing more than one character within a single quote will throw a warning and displays just the last character of the literal. It gives rise to the following two representations:
• char type: This used to store normal character literal or the narrow-character literals. This is supported by both C and C++.

Example:

```// For C
char chr = 'G';

// For C++
char chr = 'G';
```
• wchar_t type: This literal is suppoirted only in C++ and not in C. If the character is followed by L, then the literal needs to be stored in wchar_t. This represents wide-character literal.

Example:

```// Not Supported For C

// For C++
wchar_t chr = L'G';
```

Example:

## C

 `#include `` ` `int` `main()``{``    ``// constant char literal``    ``const` `char` `charVal = ``'A'``;`` ` `    ``printf``(``"Character Literal: %c\n"``,``           ``charVal);``    ``return` `0;``}`

## C++

 `#include ``using` `namespace` `std;`` ` `int` `main()``{``    ``// constant char literal``    ``const` `char` `charVal = ``'A'``;`` ` `    ``// wide char literal``    ``const` `wchar_t` `charVal1 = L``'A'``;`` ` `    ``cout << ``"Character Literal: "``         ``<< charVal << ``"\n"``;``    ``cout << ``"Wide_Character Literal: "``         ``<< charVal1 << ``"\n"``;`` ` `    ``return` `0;``}`
Output:
```Character Literal: A
```

Escape Sequences: There are various special characters that one can use to perform various operations.

4. String Literals: String literals are similar to that of the character literals, except that it can store multiple characters and uses a double quote to store the same. It can also accommodate the special characters and escape sequences mentioned in the table above.

Example:

```// For C
char stringVal[] = "GeeksforGeeks";

// For C++
string stringVal = "GeeksforGeeks"
```

Example:

## C

 `#include `` ` `int` `main()``{``    ``const` `char` `str[]``        ``= ``"Welcome\nTo\nGeeks\tFor\tGeeks"``;``    ``printf``(``"%s"``, str);``    ``return` `0;``}`

## C++

 `#include ``using` `namespace` `std;`` ` `int` `main()``{``    ``const` `string str``        ``= ``"Welcome\nTo\nGeeks\tFor\tGeeks"``;``    ``cout << str;``    ``return` `0;``}`
Output:
```Welcome
To
Geeks    For    Geeks
```
5. Boolean Literals: This literal is provided only in C++ and not in C. They are used to represent the boolean datatypes. These can carry two values:
• true: To represent True value. This must not be considered equal to int 1.
• false: To represent False value. This must not be considered equal to int 0.

Example:

 `// C++ program to show Boolean literals`` ` `#include ``using` `namespace` `std;`` ` `int` `main()``{``    ``const` `bool` `isTrue = ``true``;``    ``const` `bool` `isFalse = ``false``;`` ` `    ``cout << ``"isTrue? "``         ``<< isTrue << ``"\n"``;``    ``cout << ``"isFalse? "``         ``<< isFalse << ``"\n"``;`` ` `    ``return` `0;``}`
Output:
```isTrue? 1
isFalse? 0
```

Related articles on Constants/Literals in C/C++:

My Personal Notes arrow_drop_up