C / C++ / DBA

Teacher

Ajay Kumar Pandey

Category:

C++

4 out of 5

6 reviews

Learn Let us C Learn C++

Where is C used?

C programming finds its application across industries and can be used in many ways, such as:

In embedded systems
For the development of system applications
For the development of desktop applications
For the development of a majority of Adobe applications
For the development of browsers and the different extensions for these browsers
In the development of databases like MySQL
In the development of operating systems
To produce compilers
In IoT-related applications

How does the C programming language work?

C is a compiled programming language. A compiler is a tool used to compile a program and convert it into a machine-readable object file. When the compilation gets completed, the linker combines the various object files and produces one executable file that can be used to run the program.

These days, many compilers are available, and you may choose any of them. The functionality remains the same, and almost all of these compilers allow you to execute programs both in C and C++.

Though C was developed as a programming language for UNIX operating systems, it now has many compilers that allow it to be used across almost all hardware platforms and operating systems. When it was first beginning to become popular, the American National Standards Institute, also known as ANSI, found it necessary to create a commercial standard for the programming language. Since then, it has also been approved by the International Standards Organisation and is now sometimes referred to as “ANSI C.”

getting set up-finding a C compiler

the very first thing you need to do. before starting out in c, is to make sure that you have a compiler ,you ask ? A compiler turns the program that you write into an executable that your computer can actually understand and run.

Difference between C and C++

C is a procedural language.
No virtual function are present in C
In C , polymorphism, is not possible.
Operator over loading is not possible.
Top down approach is used in program design.
No namespace feature is present in C language

C++ is a non procedural i.e object oriented language.
the concept of virtual function are used in C++.
the concept polymorphism is the most important feature of OOP’S
operator overloading is one of the greatest feature of C++..
bottom up approach adopted in program design.
namespace feature is present in C++ for avoiding name collision

what is c?

c is a general purpose programming language created by dennis ritchie at the bell laboratories in 1972.

it is a very popular language, despite being old.

C is strongly associated with UNX, as it was developed to write the UNX operating system.

Get started with C

Let us create our first C file.

open codeblock and go to file>New> Empty file.

write the following code and save the file with (.c).

In codeblocks ,it should look like this:

then go to Build> Build and Run to run (execute) the program.

the result will look something to this:

Read the Following Code and Output:

L New Lines

New lines

To inset a new line, you can use the\n character.

Note:

two\n characters after each other will create a blank line:

What is \n exactly?

The new line character(\n) is called an escape sequence.

it forces the cursor to change its position to the beginning of the next linne on the screen. this result in a new line.

More valid escape sequences:

Create a horizontal tab \t

insert a back slash character \\

insert a double quote character \”

Comments in C

Comments are used to explain code, and to make it more readable. It can be used to prevent execution when testing alternative code.

comments can be single-lined and multi-lined.

Single-line comments

single line comments are start with two forward slashes(//).

any text between // and the end of the line is ignored by the compiler(will not be executed).

This example uses a single-line comment before a line of code:

this example uses a single-line comment at the end of a line of code:

C Multi-line comments

multi-line comments start with/* and ends with*/.

Any text between /* and*/ will be ignored by the compiler:

C Variables

A variable is nothing but a name given to a strong area that our programs can manipulate. Each variable in C has a specific type, which determine the size and layout of the variable’s memory; the range of values that can be stored within that memory; and the set of operations that can be applied to the variable.

the name of the variable can be composed of letters; digits and the underscore characters. It must being either with letter or an underscore. Upper and lower case letters are distinct because C is case-sensitive.

Types of variable

char(typically a single octal(one byte). it is an integer type).
int(the most natural size of integer for the machine).
float(a single-precision floating point value).
double(a double-precision floating point value).

Variable Definition in C

A variable definition tells the compiler where and how much storage to create for the variable. A variable definition specifies a data type and contains a list of one or more variables of that type as follows −

type variable_list;

Here, type must be a valid C data type including char, w_char, int, float, double, bool, or any user-defined object; and variable_list may consist of one or more identifier names separated by commas. Some valid declarations are shown here −

int    i, j, k;
char   c, ch;
float  f, salary;
double d;

The line int i, j, k; declares and defines the variables i, j, and k; which instruct the compiler to create variables named i, j and k of type int.

Variables can be initialized (assigned an initial value) in their declaration. The initializer consists of an equal sign followed by a constant expression as follows −

type variable_name = value;

Some examples are −

extern int d = 3, f = 5;    // declaration of d and f. 
int d = 3, f = 5;           // definition and initializing d and f. 
byte z = 22;                // definition and initializes z. 
char x = 'x';               // the variable x has the value 'x'.

For definition without an initializer: variables with static storage duration are implicitly initialized with NULL (all bytes have the value 0); the initial value of all other variables are undefined.

Variable Declaration in C

A variable declaration provides assurance to the compiler that there exists a variable with the given type and name so that the compiler can proceed for further compilation without requiring the complete detail about the variable. A variable definition has its meaning at the time of compilation only, the compiler needs actual variable definition at the time of linking the program.

A variable declaration is useful when you are using multiple files and you define your variable in one of the files which will be available at the time of linking of the program. You will use the keyword extern to declare a variable at any place. Though you can declare a variable multiple times in your C program, it can be defined only once in a file, a function, or a block of code.

Example

Try the following example, where variables have been declared at the top, but they have been defined and initialized inside the main function −

#include <stdio.h>
// Variable declaration:
extern int a, b;
extern int c;
extern float f;

int main () {

   /* variable definition: */
   int a, b;
   int c;
   float f;
 
   /* actual initialization */
   a = 10;
   b = 20;
  
   c = a + b;
   printf("value of c : %d \n", c);

   f = 70.0/3.0;
   printf("value of f : %f \n", f);
 
   return 0;
}

When the above code is compiled and executed, it produces the following result −

value of c : 30
value of f : 23.333334

The same concept applies on function declaration where you provide a function name at the time of its declaration and its actual definition can be given anywhere else. For example −

// function declaration
int func();

int main() {

   // function call
   int i = func();
}

// function definition
int func() {
   return 0;
}

Lvalues and Rvalues in C

There are two kinds of expressions in C −

lvalue − Expressions that refer to a memory location are called “lvalue” expressions. An lvalue may appear as either the left-hand or right-hand side of an assignment.
rvalue − The term rvalue refers to a data value that is stored at some address in memory. An rvalue is an expression that cannot have a value assigned to it which means an rvalue may appear on the right-hand side but not on the left-hand side of an assignment.

Variables are lvalues and so they may appear on the left-hand side of an assignment. Numeric literals are rvalues and so they may not be assigned and cannot appear on the left-hand side. Take a look at the following valid and invalid statements −

int g = 20; // valid statement

10 = 20; // invalid statement; would generate compile-time error

Data types

Specifying a data type has several reasons, including resemblance, practicality, and attention-getting. The ability to grasp complicated terminology is usually aided by effective organizing. The concept of a data type is explicitly included in almost all programming languages, albeit factors like simplicity, computability, or regularity frequently constrain the range of acceptable data types. The compiler can often select an effective machine representation with an explicit data type declaration, but the conceptual structure provided by data types should not be undervalued.

Data Types in C

Broadly, there are 5 different categories of data types in the C language, they are:

Type	Example
Basic	character, integer, floating-point, double.
Derived	Array, structure, union, etc.
Enumeration	enums
Bool type	true or false
void	Empty value

Primary Data Types in C Programming

The C language has 5 basic (primary or primitive) data types, they are:

Character (`char`):

We use the keyword char for the character data type.
It is used to store single-bit characters and occupies 1 byte of memory.

You can store alphabets from A-Z(and a-z) and 0-9 digits using char datatype. For examplechar b = 'A';

char c = '0';

char d = 0;

// ERROR

For char datatype, it is necessary to enclose the data within single quotes.
You can perform addition and subtraction operations on char datatype values.
The ASCII value of a char datatype value should not exceed 127.

Integer (`int`):

We use the keyword int for the integer data type.
The int data type is used to store non-fractional numbers which include positive, negative, and zero values.
The range of int is -2,147,483,648 to 2,147,483,647 and it occupies 2 or 4 bytes of memory, depending on the system you’re using. For example,
```
int a = 5550; 
int b = -90, 
int c = 0; 
int d = -0.5; //invalid
```
We can perform addition, subtraction, division, multiplication, bitwise, and modulo operations on int data type.

Floating-point (`float`):

We use the keyword float for a floating-point data type.
The keyword float is used to store decimal numbers.
It occupies 4 bytes of memory and ranges from 1e-37 to 1e+37.

For example,

float a = 0.05; 
float b = -0.005.
float c = 1;  // it will become c = 1.000000 because of type-casting

We can perform addition, subtraction, division, and multiplication operations on float data type.

Double (`double`):

We use the keyword double for the double data type.
The double datatype is used to store decimal numbers.
It occupies 8 bytes of memory and ranges from 1e-37 to 1e+37.
Here is how we use it in code,
```
double a = 10.09;
double b = -67.9;
```
The double datatype has more precision than float so double gives more accurate results as compared to float.
We can perform addition, subtraction, division, and multiplication operations on double data type.

Void (`void`):

This means no value.
This data type is mostly used when we define functions.
The void datatype is used when a function does not return any result.
It occupies 0 bytes of memory.
We use the void keyword for void data type.

Here is how we use the void type with functions,

void function() { //your code goes here }

Size of different Datatypes in C

The size of different data types depends on the compiler and processor types.
In short, it depends on the Computer on which you are running the C language and the version of the C compiler that you have installed.

1. char is 1 byte

The char datatype is 1 byte in size or 8 bits.
This is mostly the same and is not affected by the processor or the compiler used.

2. int can be 2 bytes/4 bytes

There is a very easy way to remember the size of int datatype.
The size of int datatype is usually equal to the word length of the execution environment of the program.
In simpler words, for a 16-bit environment, int is 16 bits or 2 bytes, and for a 32-bit environment, int is 32 bits or 4 bytes.

3. float is 4 bytes

The float datatype is 4 bytes or 32 bits in size.
It is a single-precision data type that is used to hold decimal values.
It is used for storing large values.
float is a faster data type compared to double, because double data type works with very large values, hence it is slow.

4. double is 8 bytes

The double datatype is 8 bytes or 64 bits in size.
It can store values that are double the size of what a float data type can store, hence it is called double.
In the 64 bits, 1 bit is for sign representation, 11 bits for the exponent, and the rest 52 bits are used for the mantissa.
The double data type can hold approximately 15 to 17 digits, before the decimal and after the decimal.

5. void is 0 bytes

The void datatype means nothing, hence it doesn’t have a size.

Before moving on to the range of values for these data types, there is one more important concept to learn, which is Datatype modifiers.

C Data type Modifiers:

There are 4 datatype modifiers in C programming that are used along with the basic data types to categorize them further.

For example, if you say, there is a playground, it can be a park, a playground, or a stadium, but if you say, there is a Cricket ground or a Football stadium, that would make it even more precise.

Similarly, there are modifiers in the C language, to make the primary data types more specific.

The following are the modifiers:

signed
unsigned
long
short

As the name suggests,

signed and unsigned are used to represent the signed(+ and -) and unsigned(only +) values for any data type.
And long and short affects the range of the values for any datatype.

For example, signed int, unsigned int, short int, long int, etc. are all valid data types in the C language.

long long num = 123456789987654321; // we cannot store a value this big value using int data type.

Now let’s see the range for different data types formed as a result of the 5 primary data types along with the modifiers specified above.

C Data type Value Range

In the table below we have the range for different data types in the C language.

Type	Typical Size in Bits	Minimal Range	Format Specifier
`char`	8	-127 to 127	`%c`
`unsigned` `char`	8	0 to 255	`%c`
`signed` `char`	8	-127 to 127	`%c`
`int`	16 or 32	-32,767 to 32,767	`%d`, `%i`
`unsigned` `int`	16 or 32	0 to 65,535	`%u`
`signed` `int`	16 or 32	Same as int	`%d`, `%i`
`short` `int`	16	-32,767 to 32,767	`%hd`
`unsigned` `short` `int`	16	0 to 65,535	`%hu`
`signed` `short` `int`	16	Same as short int	`%hd`
`long` `int`	32	-2,147,483,647 to 2,147,483,647	`%ld`, `%li`
`long` `long` `int`	64	-(2⁶³ – 1) to 2⁶³ – 1 (Added by C99 standard)	`%lld`, `%lli`
`signed` `long` `int`	32	Same as long int	`%ld`, `%li`
`unsigned` `long` `int`	32	0 to 4,294,967,295	`%lu`
`unsigned` `long` `long` `int`	64	2⁶⁴ – 1 (Added by C99 standard)	`%llu`
`float`	32	1E-37 to 1E+37 with six digits of precision	`%f`
`double`	64	1E-37 to 1E+37 with ten digits of precision	`%lf`
`long` `double`	80	1E-37 to 1E+37 with ten digits of precision	`%Lf`

As you can see in the table above, with different combinations of the datatype and modifiers the range of value changes.

When we want to print the value for any variable with any datatype, we have to use a format specifier in the printf() statement.

What happens if the value is out of Range?

Well, if you try to assign a value to any datatype which is more than the allowed range of value, then the C language compiler will give an error. Here is a simple code example to show this,

#include <stdio.h>

int main() {
   // allowed value up to 65535
   unsigned short int x = 65536;
  
   return 0;
}

Output

warning: large integer implicitly truncated to unsigned type [-Woverflow]

unsigned short int x = 65536; ^

What does `signed` and `unsigned` means?

This is a little tricky to explain, but let’s try.

In simple words, the unsigned modifier means all positive values, while the signed modifier means both positive and negative values.
When the compiler gets a numeric value, it converts that value into a binary number, which means a combination of 0 and 1. For example, 32767 in binary is 01111111 11111111, 1 in binary is 01 (or 0001), 2 is 0010, and so on.
In the case of a signed integer, the highest order bit or the first digit from left (in binary) is used as the sign flag.
If the sign flag is 0, the number is positive, and if it is 1, the number is negative.
And because one bit is used for showing if the number is positive or negative, hence there is one less bit to represent the number itself, hence the range is less.
For signed int, 11111111 11111111 means -32,767, and because the first bit is a sign flag to mark it as a negative number, and the rest represents the number.
Whereas in the case of unsigned int, 11111111 11111111 means 65,535.

Derived Data types in C

While there are 5 primary data types, there are some derived data types too in the C language which are used to store complex data.

Derived data types are nothing but primary data types but a little twisted or grouped together like an array, structure, union, and pointers.

Operators

Operators are used to perform operations on variables and values.

In the example below, we use the + operator to add together two values:

Example

int myNum = 100 + 50;

Although the + operator is often used to add together two values, like in the example above, it can also be used to add together a variable and a value, or a variable and another variable:

Example

int sum1 = 100 + 50;        // 150 (100 + 50)
int sum2 = sum1 + 250;      // 400 (150 + 250)
int sum3 = sum2 + sum2;     // 800 (400 + 400)

C divides the operators into the following groups:

Arithmetic operators
Assignment operators
Comparison operators
Logical operators
Bitwise operators

Arithmetic Operators

Arithmetic operators are used to perform common mathematical operations.

Operator	Name	Description	Example
+	Addition	Adds together two values	x + y
–	Subtraction	Subtracts one value from another	x – y
*	Multiplication	Multiplies two values	x * y
/	Division	Divides one value by another	x / y
%	Modulus	Returns the division remainder	x % y
++	Increment	Increases the value of a variable by 1	++x
—	Decrement	Decreases the value of a variable by 1	–x

Assignment Operators

Assignment operators are used to assign values to variables.

In the example below, we use the assignment operator (=) to assign the value 10 to a variable called x:

Example

int x = 10;

The addition assignment operator (+=) adds a value to a variable:

Example

int x = 10;
x += 5;

A list of all assignment operators:

Operator	Example	Same As
=	x = 5	x = 5
+=	x += 3	x = x + 3
-=	x -= 3	x = x – 3
*=	x *= 3	x = x * 3
/=	x /= 3	x = x / 3
%=	x %= 3	x = x % 3
&=	x &= 3	x = x & 3
\|=	x \|= 3	x = x \| 3
^=	x ^= 3	x = x ^ 3
>>=	x >>= 3	x = x >> 3
<<=	x <<= 3	x = x << 3

Comparison Operators

Comparison operators are used to compare two values (or variables). This is important in programming, because it helps us to find answers and make decisions.

The return value of a comparison is either 1 or 0, which means true (1) or false (0). These values are known as Boolean values, and you will learn more about them in the Booleans and If..Else chapter.

In the following example, we use the greater than operator (>) to find out if 5 is greater than 3:

Example

int x = 5;
int y = 3;
printf(“%d”, x > y); // returns 1 (true) because 5 is greater than 3

A list of all comparison operators:

Operator	Name	Example
==	Equal to	x == y
!=	Not equal	x != y
>	Greater than	x > y
<	Less than	x < y
>=	Greater than or equal to	x >= y
<=	Less than or equal to	x <= y

Logical Operators

You can also test for true or false values with logical operators.

Logical operators are used to determine the logic between variables or values:

Operator	Name	Description	Example
&&	Logical and	Returns true if both statements are true	x < 5 && x < 10
\|\|	Logical or	Returns true if one of the statements is true	x < 5 \|\| x < 4
!	Logical not	Reverse the result, returns false if the result is true	!(x < 5 && x < 10)

Sizeof Operator

The memory size (in bytes) of a data type or a variable can be found with the sizeof operator:

Example

int myInt;
float myFloat;
double myDouble;
char myChar;

printf(“%lu\n”, sizeof(myInt));
printf(“%lu\n”, sizeof(myFloat));
printf(“%lu\n”, sizeof(myDouble));
printf(“%lu\n”, sizeof(myChar));

Booleans

Very often, in programming, you will need a data type that can only have one of two values, like:

YES / NO
ON / OFF
TRUE / FALSE

For this, C has a bool data type, which is known as booleans.

Booleans represent values that are either true or false.

Boolean Variables

In C, the bool type is not a built-in data type, like int or char.

It was introduced in C99, and you must import the following header file to use it:

#include <stdbool.h>

A boolean variable is declared with the bool keyword and can only take the values true or false:

bool isProgrammingFun = true;
bool isFishTasty = false;

Before trying to print the boolean variables, you should know that boolean values are returned as integers:

1 (or any other number that is not 0) represents true
0 represents false

Therefore, you must use the %d format specifier to print a boolean value:

Example

// Create boolean variables
bool isProgrammingFun = true;
bool isFishTasty = false;

// Return boolean values
printf(“%d”, isProgrammingFun); // Returns 1 (true)
printf(“%d”, isFishTasty); // Returns 0 (false)

However, it is more common to return a boolean value by comparing values and variables.

Comparing Values and Variables

Comparing values are useful in programming, because it helps us to find answers and make decisions.

For example, you can use a comparison operator, such as the greater than (>) operator, to compare two values:

Example

printf(“%d”, 10 > 9); // Returns 1 (true) because 10 is greater than 9

From the example above, you can see that the return value is a boolean value (11).

You can also compare two variables:

Example

int x = 10;
int y = 9;
printf(“%d”, x > y);

In the example below, we use the equal to (==) operator to compare different values:

Example

printf(“%d”, 10 == 10); // Returns 1 (true), because 10 is equal to 10
printf(“%d”, 10 == 15); // Returns 0 (false), because 10 is not equal to 15
printf(“%d”, 5 == 55); // Returns 0 (false) because 5 is not equal to 55

You are not limited to only compare numbers. You can also compare boolean variables, or even special structures, like arrays (which you will learn more about in a later chapter):

Example

bool isHamburgerTasty = true;
bool isPizzaTasty = true;

// Find out if both hamburger and pizza is tasty
printf(“%d”, isHamburgerTasty == isPizzaTasty);

Remember to include the <stdbool.h> header file when working with bool variables.

Real Life Example

Let’s think of a “real life example” where we need to find out if a person is old enough to vote.

In the example below, we use the >= comparison operator to find out if the age (29) is greater than OR equal to the voting age limit, which is set to 19:

Example

int myAge = 25;
int votingAge = 18;

printf(“%d”, myAge >= votingAge); // Returns 1 (true), meaning 25 year olds are allowed to vote!

Cool, right? An even better approach (since we are on a roll now), would be to wrap the code above in an if...else statement, so we can perform different actions depending on the result:

Example

Output “Old enough to vote!” if myage is greater than or equal to 19. Otherwise output “Not old enough to vote.”:

int myAge = 25;
int votingAge = 18;

if (myAge >= votingAge) {
printf(“Old enough to vote!”);
} else {
printf(“Not old enough to vote.”);
}

Conditions and If Statements

You have already learned that C supports the usual logical conditions from mathematics:

Less than: a < b
Less than or equal to: a <= b
Greater than: a > b
Greater than or equal to: a >= b
Equal to a == b
Not Equal to: a != b

You can use these conditions to perform different actions for different decisions.

C has the following conditional statements:

Use if to specify a block of code to be executed, if a specified condition is true
Use else to specify a block of code to be executed, if the same condition is false
Use else if to specify a new condition to test, if the first condition is false
Use switch to specify many alternative blocks of code to be executed

The if Statement

Use the if statement to specify a block of code to be executed if a condition is true.

Syntax

if (condition) {
// block of code to be executed if the condition is true
}

Note that if is in lowercase letters. Uppercase letters (If or IF) will generate an error.

In the example below, we test two values to find out if 20 is greater than 18. If the condition is true, print some text:

Example

if (20 > 18) {
printf(“20 is greater than 18”);
}

We can also test variables:

Example

int x = 20;
int y = 18;
if (x > y) {
printf(“x is greater than y”);
}

Example explained

In the example above we use two variables, x and y, to test whether x is greater than y (using the > operator). As x is 20, and y is 18, and we know that 20 is greater than 18, we print to the screen that “x is greater than y”.

The else Statement

Use the else statement to specify a block of code to be executed if the condition is false.

Syntax

if (condition) {
// block of code to be executed if the condition is true
} else {
// block of code to be executed if the condition is false
}

Example

int time = 20;
if (time < 18) {
printf(“Good day.”);
} else {
printf(“Good evening.”);
}
// Outputs “Good evening.”

Example explained

In the example above, time (20) is greater than 18, so the condition is false. Because of this, we move on to the else condition and print to the screen “Good evening”. If the time was less than 18, the program would print “Good day”.

The else if Statement

Use the else if statement to specify a new condition if the first condition is false.

Syntax

if (condition1) {
  // block of code to be executed if condition1 is true
} else if (condition2) {
  // block of code to be executed if the condition1 is false and condition2 is true
} else {
  // block of code to be executed if the condition1 is false and condition2 is false
}

Example

int time = 22;
if (time < 10) {
printf(“Good morning.”);
} else if (time < 20) {
printf(“Good day.”);
} else {
printf(“Good evening.”);
}
// Outputs “Good evening.”

example explained

In the example above, time (22) is greater than 10, so the first condition is `false`. The next condition, in the `else if` statement, is also `false`, so we move on to the `else` condition since condition1 and condition2 is both `false` – and print to the screen “Good evening”.

However, if the time was 14, our program would print “Good day.”

Another Example

This example shows how you can use if..else to find out if a number is positive or negative:

Example

int myNum = 10; // Is this a positive or negative number?

if (myNum > 0) {
printf(“The value is a positive number.”);
} else if (myNum < 0) {
printf(“The value is a negative number.”);
} else {
printf(“The value is 0.”);
}

Short Hand If…Else (Ternary Operator)

There is also a short-hand if else, which is known as the ternary operator because it consists of three operands. It can be used to replace multiple lines of code with a single line. It is often used to replace simple if else statements:

Syntax

variable = (condition) ? expressionTrue : expressionFalse;

Instead of writing:

Example

int time = 20;
if (time < 18) {
printf(“Good day.”);
} else {
printf(“Good evening.”);

You can simply write:

Example

int time = 20;
(time < 18) ? printf(“Good day.”) : printf(“Good evening.”);It is completely up to you if you want to use the traditional if…else statement or the ternary operator.

C switch Statement

The switch statement allows us to execute one code block among many alternatives.

You can do the same thing with the if...else..if ladder. However, the syntax of the switch statement is much easier to read and write.

Syntax of switch…case

switch (expression)
{
    case constant1:
      // statements
      break;

    case constant2:
      // statements
      break;
    .
    .
    .
    default:
      // default statements
}

How does the switch statement work?

The expression is evaluated once and compared with the values of each case label.

If there is a match, the corresponding statements after the matching label are executed. For example, if the value of the expression is equal to constant2, statements after case constant2: are executed until break is encountered.
If there is no match, the default statements are executed.

Notes:

If we do not use the break statement, all statements after the matching label are also executed.
The default clause inside the switch statement is optional.

switch Statement Flowchart

Flowchart of switch statement — switch Statement Flowchart

Example: Simple Calculator

// Program to create a simple calculator
#include <stdio.h>

int main() {
    char operation;
    double n1, n2;

    printf("Enter an operator (+, -, *, /): ");
    scanf("%c", &operation);
    printf("Enter two operands: ");
    scanf("%lf %lf",&n1, &n2);

    switch(operation)
    {
        case '+':
            printf("%.1lf + %.1lf = %.1lf",n1, n2, n1+n2);
            break;

        case '-':
            printf("%.1lf - %.1lf = %.1lf",n1, n2, n1-n2);
            break;

        case '*':
            printf("%.1lf * %.1lf = %.1lf",n1, n2, n1*n2);
            break;

        case '/':
            printf("%.1lf / %.1lf = %.1lf",n1, n2, n1/n2);
            break;

        // operator doesn't match any case constant +, -, *, /
        default:
            printf("Error! operator is not correct");
    }

    return 0;
}

Output

Enter an operator (+, -, *, /): -
Enter two operands: 32.5
12.4
32.5 - 12.4 = 20.1

The – operator entered by the user is stored in the operation variable. And, two operands 32.5 and 12.4 are stored in variables n1 and n2 respectively.

Since the operation is -, the control of the program jumps to

printf("%.1lf - %.1lf = %.1lf", n1, n2, n1-n2);

Finally, the break statement terminates the switch statement.

C while loop

Description

The most basic loop in C is the while loop and it is used is to repeat a block of code. A while loop has one control expression (a specific condition) and executes as long as the given expression is true. Here is the syntax :

Syntax:

while (condition)
{ 
 statement(s);
 }

In while loop first the condition (boolean expression) is tested; if it is false the loop is finished without executing the statement(s). If the condition is true, then the statements are executed and the loop executes again and again until the condition is false.
If there is only one statement, the braces may be omitted; however, it is good practice to always include the braces.

See the flowchart :

A Simple While Loop Example -1

The following program prints n asterisks.

Example – 2:

The following program prints two numbers.

#include <stdio.h>
main()
{
int m = 5;
int n = 0;
while (m > n)
{
printf("m = %d n = %d\n",m,n );
m--;
n++;
}
}

  m = 5 n = 0
  m = 4 n = 1
  m = 3 n = 2

Explanation

The loop will terminate when m becomes equal to or lesser than n, hence m <= n is the terminating condition of the while loop.

The loop has executed 3 times.

The condition m>n has checked 4 times.

First time : m = 5 and n = 0, this time the condition is true, so loop is executed.
Second time : m = 4, and n = 1. Again the condition is true, so the loop is executed.
Third time : m = 3 and n = 2. Again the condition is true so the loop is executed.
Fourth time : m = 2 and n = 3. Now the condition is false, hence loop is not executed.
Therefore this is the last time the condition m>n is checked in the program.

Here is the flowchart of the above program

C for loop

Description

A “For” Loop is used to repeat a specific block of code (statements) a known number of times. The for-loop statement is a very specialized while loop, which increases the readability of a program. Here is the syntax of the of for loop.

for ( initialize counter ; test counter ; increment counter)
{
execute the statement(s);
}

initialize counter : Initialize the loop counter value.
test counter : Verify the loop counter whether the condition is true.
increment counter : Increasing the loop counter value.
execute the statement : Execute C statements.

Note : The for-loop must have two semi-colons between the opening and closing parenthesis.

The following picture has clearly described the for loop syntax.

Why For Loops?

1. ” For” loops execute blocks of code over and over again.

2. It is clear to a developer exactly how many times the loop will execute before the loop starts.

3. The Syntax of the for loop is almost same to other programming languages.

For loop repetition statement

Here are some example of for loop repetition statements.

The following code prints the numbers from 1 to 100 in increments of 1.

for ( int x = 1; x <= 100 ; x++ )
  {
  printf("%d\n",x);
  }

The following code prints the numbers from 100 to 1 in increments of -1.

for(int x = 100 ; x >= 1; x--)
  {
  printf("%d\n",x);
  }

The following code prints the numbers from 8 to 88 in steps of 8

for(int x = 8; x <= 88 ; x += 8)
  {
  printf("%d\n",x);
  }

The following code prints : 2, 7, 12, 17, 22, 27

for(int x = 2; x <= 30 ; x += 5)
  {
  printf("%d\n",x);
  }

The following code prints: 66, 60, 54, 48, 42, 36, 30, 24, 18, 12, 6, 0

for(int x = 66 ; x >= 0; x -= 6 )
  {
  printf("%d\n",x);
  }

For loop Examples

Example – 1:

The following program calculate the sum of 1+2+3+…+50. The sum is stated in sum = sum + x, where i takes values from 1 to 50.

#include<stdio.h>
main()
{
int sum; int x; sum=0;
 for(x=1;x<=50;++x) 
 // x take values in {1,2,3,...,50}
 {
 sum = sum + x; 
 }
 printf(" 1+2+...+50=%d\n",sum);
}

Output:

 1+2+...+50=1275

Example – 2:

The following program will ask the user to input 10 integers and find the sum.

#include<stdio.h>
main() 
{ 
int z;
int x, sum=0, inpn;
// initialization 
for(x=1; x<=10; ++x) 
// Ask user 10 times(i.e. x takes 10 integers) 
{
printf("Enter #%d: ",x); 
scanf("%d",&inpn); 
sum = sum + inpn;
// Accumulate the next value 
} 
printf("Total Sum of 10 numbers = %d\n",sum); 
}

Output:

  Enter #1: 1
  Enter #2: 1
  Enter #3: 1
  Enter #4: 1
  Enter #5: 1
  Enter #6: 1
  Enter #7: 1
  Enter #8: 1
  Enter #9: 1
  Enter #10: 2
  Total Sum of 10 numbers = 11

Example – 3:

The following program will ask the user to input 5 numbers and print out the maximum and minimum numbers from the set.

#include<stdio.h>
main() 
{ 
int Max, Min, Inpn, x; 
printf("Input #1: "); 
scanf("%d",&Inpn); 
Max = Inpn; 
Min = Inpn;
// Call the First number as current maximum and minimum
for(x=2;x<=5;++x) 
{ 
printf("Input #%d: ",x); 
scanf("%d",&Inpn);
if(Inpn>Max) 
// if the next number is bigger than current maximum, store it 
{
Max = Inpn;
} 
if(Inpn<Min) 
// if the next number is lower than current minimum, store it 
{
Min = Inpn; 
} 
} 
printf(" The Maximum # is %d\n",Max);
printf(" The Minimum # is %d\n",Min);
}

Output:

Input #1: 120
  Input #2: 34
  Input #3: 0
  Input #4: 1234
  Input #5: -500
The Maximum # is 1234
The Minimum # is -500

Example – 4:

A prime number is a number that is only divisible by 1 and itself. We can check whether a number x is prime by checking if it is divisible by any of the numbers between 2 to x-1. For example if an user input a number say 5, then we will check if 5 is divisible by 2, 3 or 4. If 5 is divisible by 2, 3 or 4 then we can say that 5 is not prime. In the following program we use a for loop to iterate with y over the numbers 2,3,….x-1 and check if y is divided by the number x. Within if statement we use an indicator (z=1) to mark that x is not prime and during the for loop execution if the reminder of x and y is found 0 the break statement will cause the loop to exit.

#include<stdio.h>
main()
{
int x, z;
z=0;
printf("Input a number : ",x); 
scanf("%d",&x); 
for(int y = 2; y<x; y++)
   {
     if (x%y == 0)
	  {
    // y divides x - not  a prime number
	   printf("%d is not a prime number",x);
	   z=1;
	   break;
      }
    }
if (z==0)
 {
  printf("%d is a prime number",x);
 }
}

Output:

Input a number : 7
  7 is a prime number

Input a number : 8
  8 is not a prime number

C Break and Continue

Break

You have already seen the break statement used in an earlier chapter of this tutorial. It was used to “jump out” of a switch statement.

The break statement can also be used to jump out of a loop.

This example jumps out of the for loop when i is equal to 4:

Example

int i;

for (i = 0; i < 10; i++) {
if (i == 4) {
break;
}
printf(“%d\n”, i);
}

Continue

The continue statement breaks one iteration (in the loop), if a specified condition occurs, and continues with the next iteration in the loop.

This example skips the value of 4:

Example

int i;

for (i = 0; i < 10; i++) {
if (i == 4) {
continue;
}
printf(“%d\n”, i);
}

Break and Continue in While Loop

You can also use break and continue in while loops:

Break Example

int i = 0;

while (i < 10) {
if (i == 4) {
break;
}
printf(“%d\n”, i);
i++;
}

Continue Example

int i = 0;

while (i < 10) {
  if (i == 4) {
    i++;
    continue;
}
printf(“%d\n”, i);
  i++;
}

Arrays in C

Description

Suppose we want to store 50 student names of a class. One might try to declare 50 variables, say st_name0, st_name1,..,st_name49. However, it is much better to deﬁne all those names in a single variable, which is called an array.

– An array is a collection of data of the same type (and therefore, the same size) stored in consecutive memory cells under one name.

– An entire array is declared all at once.

– Each individual element in the array can be referenced by indexing. Indexed means the array elements are numbered and always start at 0.

In C, an element of an array (i.e., an individual data item) is referred to by specifying the array name followed by one or more subscripts, with each subscript enclosed in square brackets.

Declaring an Array

An array declaration is similar to the form of a normal declaration. The general form is :

typeName ArrayName[size] = { list of values }

This declares an array with the specified size, named ArrayName and type typeName. The array is indexed from 0 to (size-1). The size (in brackets) must be an integer literal or a constant variable. The compiler uses the size to determine how much space to allocate (i.e. how many bytes). Here are some examples :

int A[10];            // An array of ten integers; A[0], A[1], …, A[9]
char name[20];           // An array of 20 characters
float nums[50]; // An array of fifty floating numbers; nums[0], nums[1], …,nums[49]
int C[]; // An array of an unknown number of integers; C[0], C[1], …, C[size-1]
int table[5][10];        // A two dimensional array of integers

You can also declare an array in the following way :

#define ROLL_NUMBERS 51
  int  classv[ROLL_NUMBERS];
const int Emp_salary = 35
  float Employee[Emp_salary];

Example: int A[10];

Declares 10 integers and can be accessed by the name A
Each variable is assigned a unique location (location is also called as an index). The range of the location is 0 to (length – 1). For the said array range of the location is 0 to 9.

See the following diagram which represent the array A[10] :

Index	0	1	2	3	4	5	6	7	8	9
Value	15	8	14	45	48	45	-57	45	1	0

Indexing into Arrays

To refer a single array element use arrayname[index].

For example :

A[4] contains the value 48

A[9] contains the value 0

Indexed elements can be used just like simple variables.

printf(“%d\n”, A[4]); // print 48

Array elements and loops

Array elements are commonly used in for loops, see the following codes :

for(x=0; x < max; x++)
  A[x] = x*x;
sum = 0; 
  for(x=0; x < max; x++)
  sum += B[x];

Array Initialization

We declare normal variables in the following ways :

int x;
x = 0;
or
int x = 0;

In the case of an array, simply list the array values in set notation { }. Some valid array declarations are shown below.

int num[6] = {1, 3, 5, 7, 9, 11};
char letters[5] = {‘a’, ‘b’, ‘c’, ‘d’, ‘e’};
float numbers[3] = {13.25, 12.09, 8.1};

Using Array Elements in Expressions

Array elements may be used wherever a variable of the same type may be used. See the following diagram and codes.

Example: int A[10];

Index	0	1	2	3	4	5	6	7	8	9
value	15	8	14	45	48	45	-57	45	1	0

x = A[1] * 2; /* sets x to 16 */

A[4] = 88; /* replaces 48 with 88 */

m = 6;

y = A[m]; /* sets y to –57 */

z = A[A[9]]; /* sets z to 15 */

Example -1:

There are seven numbers stored in an array. The following program prints all the numbers of that array as well as prints the numbers in backward.

#include<stdio.h>
int main()
{
int M[10];
int j;
/* store seven numbers in array M */
 M[0] = 2;
 M[1] = 4;
 M[2] = 6;
 M[3] = 8;
 M[4] = 10;
 M[5] = 12;
 M[6] = 14;
/* print numbers in M */
 printf("Print all the Numbers : \n");
 for (j = 0; j < 7; ++j)
 printf("M[%d] = %d\n",j,M[j]);
/* print numbers in M backwards */
 printf("\nFrom End to Beginning : \n");
 for (j = 6; j >= 0; --j)
 {
 printf("M[%d] = %d\n",j,M[j]);
  }
}

Output:

Example -2 :

The following program computes prime numbers between 1 to MXNO.

#include<stdio.h>
  #define MXNO 50
int main()
{
  int M[MXNO];
  int j, n;
 /* mark all numbers */
  printf("The prime numbers are :\n\n");
  for (j = 0; j < MXNO; ++j)
  {
  M[j] = 1;
  }
  for (j = 2; j < MXNO; ++j)
  {
  if (M[j])
  {
  printf("%d\n", j);
  }
  for (n = j+j; n < MXNO; n+= j)
  {
  M[n] = 0;
  }
  }
}

Copying arrays:

We have two arrays list1 and list2

int list1[6] = {2, 4, 6, 8, 10, 12};

int list2[6];

and we want to copy the contents of list1 to list2. For general variables (e.g. int x=3, y=5) we use simple assignment statement (x=y or y=x). But for arrays the following statement is wrong.

list2 = list1;

We must copy between arrays element by element and the two arrays must have the same size. In the following example, we use a for loop which makes this easy.

#include <stdio.h>
main()
int list1[6] = {2, 4, 6, 8, 10, 12};
int list2[6];
for (int ctr = 0; ctr<6; ctr++)
{
 list2[ctr] = list1[ctr];
}
 printf("Elements of list2 :\n"); 
 for (int ctr = 0; ctr<6; ctr++)
 {
  printf("%d ",list2[ctr]);
 }
}

Output:

Elements of list2 :
2 4 6 8 10 12

Two dimensional Array in C

A two-dimensional array can be used to represent a matrix, a table or board games (Tic Tac Toe, Sudoku etc). The row and column positions are given as successive indices. When you declare a variable of such an array, use a pair of square brackets for each dimension. See the following example :

// Declare a two-dimensional array with 3 rows and 2 columns
int table[3][2]:
// create and initialize  an array
int table[3][2] = { {10, 22}, {33, 44}, {45, 78} };

int table[3][2] = {10, 22, 33, 44, 45, 78 };

int table[3][2] = {
{10, 22},
{33, 44 },
{45, 78 }
 };

See the following diagram which represents the above array :

	0	1
0	10	22
1	33	44
2	45	78

In the above array :

table[1][1] contains 22

table[2][0] contains 45

table[2][2] is “array out of bounds”

Printing a Two-dimensional array

To print all the elements of a two dimension array we use a doubly-nested for-loop. In the following example, there are 3 rows and 2 columns.

#include <stdio.h>
main()
{
  int row,col;
  int table[3][2] = { {10, 22}, {33, 44}, {45, 78} };
  for (row = 0; row < 3; row++)
  {
  for (col = 0; col < 2; col++)
  {
  printf("%d\t",table[row][col]);
  }
  printf("\n");
  } 
}

Output:

String in C Programming

String in C programming language is a one-dimensional array of characters which is terminated by a null character(‘\0’). A character array which is not null terminated is not a valid C string. In a C string, each character occupies one byte of memory including null character.

Null character marks the end of the string, it is the only way for the compiler to know where this string is ending. Strings are useful when we are dealing with text like Name of a person, address, error messages etc.

Examples of C Strings

“A”
“prathamguru”
“prathamguru”
” “
“_18u,768JH”
“PROGRAM”

Below is the representation of string in memory.

Points to Remember about Strings in C

- C Strings are single dimensional array of characters ending with a null character(‘\0’).

- Null character marks the end of the string.

- Strings constants are enclosed by double quotes and character are enclosed by single quotes.
  
  For Example
  
  String constant : “prathamguru”
  Character constant: ‘p’

- If the size of a C string is N, it means this string contains N-1 characters from index 0 to N-2 and last character at index N-1 is a null character.

- Each character of string is stored in consecutive memory location and occupy 1 byte of memory.

The ASCII value of null character(‘\0’) is 0.

Declaration of Strings in C

String is not a basic data type in C programming language. It is just a null terminated array of characters. Hence, the declaration of strings in C is similar to the declaration of arrays.

Like any other variables in C, strings must be declared before their first use in C program.

Syntax of String Declaration

char string_name[SIZE_OF_STRING];

In the above declaration, string_name is a valid C identifier which can be used later as a reference to this string. Remember, name of an array also specifies the base address of an array.

SIZE_OF_STRING is an integer value specifying the maximum number of characters which can be stored in this string including terminating null character. We must specify size of string while declaration if we are not initializing it.

Examples of String Declaration

char address[100];
char welcomeMessage[200];

C Does not provide support for boundary checking i.e if we store more characters than the specified size in string declaration then C compiler will not give you any error.

Initialization of Strings

In C programming language, a string can be initialized at the time of declarations like any other variable in C. If we don’t initialize an array then by default it will contain garbage value.

There are various ways to initialize a String Initialization of string using a character array

char name[16] ={'P','r','a','t','h','a','m','g','u','r','u','\0'}; 
or
char name[] = {'P','r','a','t','h','a','m','g','u','r','u','\0'};

In the above declaration individual characters are written inside single quotes(”) separated by comma to form a list of characters which is wrapped in a pair or curly braces. This list must include a null character as last character of the list.

If we don’t specify the size of String then length is calculated automatically by the compiler.

Initialization of string using string literal

char name[11] = "prathamguru"; or char name[] = "prathamguru";

In above declaration a string with identifier “name” is declared and initialized to “prathamguru“. In this type of initialization , we don’t need to put terminating null character at the end of string constant. C compiler will automatically inserts a null character(‘\0’), after the last character of the string literal.

If we don’t specify the size of String then length is calculated automatically by the compiler. The length of the string will be one more than the number of characters in string literal/constant.

Initialization of string using character pointer

char *name = "prathamguru";

In the above declaration, we are declaring a character pointer variable and initializing it with the base address of a string constant. A null terminating character is automatically appended by the compiler. The length of the string will be one more than the number of characters in string constant.

C Program showing String Initialization

#include <stdio.h>
  
void main(){  
   char nameOne[16] ={'P','r','a','t','h','a','m','g','u','r','u','\0'};
   charnameTwo[] = 
{'P','r','a','t','h','a','m','g','u','r','u','\0'};
 char nameThree[16] = "prathamguru";
   char nameFour[] = "prathamguru";
   char *nameFive = "prathamguru";
   
   printf("%s\n", nameOne); 
   printf("%s\n", nameTwo); 
   printf("%s\n", nameThree); 
   printf("%s\n", nameFour);
   printf("%s\n", nameFive); 
    
   return 0; 
}

Output

prathamguru
prathamguru
prathamguru
prathamguru
prathamguru

String Input Output in C

Standard library functions for reading strings

gets() : Reads a line from stdin and stores it into given character array.
scanf() : Reads formatted data from stdin.
getchar() : Returns a character from stdin stream.
fscanf() : Read formatted data from given stream.

Standard library functions for printing strings

puts() : Writes a string to stdout stream excluding null terminating character.
printf() : Print formatted data to stdout.
putchar() : Writes a character to stdout stream.
fprintf() : Writes formatted output to a stream.

C Program to read and print strings

#include <stdio.h>
 
int main(){
    char name[30], city[100], country[100];
    char c;
    int i=0;
     
    printf("Enter name: ");
    /* Reading string using gets function */
    gets(name);
     
    printf("Enter city: ");
    /* Reading string using getchar function */
    while((c = getchar()) != '\n'){
        city[i]=c;
        i++;
    }
    city[i]='\0';
     
    printf("Enter country: ");
    /* Reading string using scanf function */
    scanf("%s", country);
     
    /* Printing string using printf() */
    printf("%s\n", name);
    /* Printing string using puts() */
    puts(city);
    /* Printing string using putchar() */
    for(i=0; country[i] != '\0'; i++)
       putchar(country[i]);
     
    return 0;
}

Output

Enter name: Jack
Enter city: New York
Enter country: USA
Jack
New York
USA

String Handling Standard Library Function

string.h header file contains a wide range of functions to manipulate null-terminated C strings.
Below are some commonly used string handling functions of string.h header file.

Function	Description
strcat()	It appends one string at the end of another string.
strchr()	It searches for the first occurrence of a character in the string.
strcmp()	It compares two strings character by character.
strcpy()	It copies characters from one string into another string.
strlen()	It returns the length of a string.
strstr()	It searches for the first occurrence of a string in another string.
strtok()	It breaks a string into smaller tokens.

C Program to show the use of string handling functions of string.h header file

#include <stdio.h>
#include <string.h>
 
int main(){
   char inputString[50];
   char copyString[60];
    
   printf("Enter a string: ");
   gets(inputString);
 
   /* Printing length of string using strlen() */
   printf("Length of %s : %d\n", inputString, strlen(inputString));
 
   /* copying inputString into copyString */
   strcpy(copyString, inputString);
   printf("Copied String : %s\n", copyString);
 
   /* comparing inputString and copyString string*/
   if(strcmp(copyString, inputString)){
       printf("Both Strings are Not Equal\n");
   } else {
       printf("Both Strings are Equal\n");
   }
 
   return 0;
}

Output

Enter a string: prathamguru
Length of prathamguru : 11
Copied String : prathamguru
Both Strings are Equal

User Input

You have already learned that printf() is used to output values in C.

To get user input, you can use the scanf() function:

Example

Output a number entered by the user:

// Create an integer variable that will store the number we get from the user
int myNum;

// Ask the user to type a number
printf(“Type a number: \n”);

// Get and save the number the user types
scanf(“%d”, &myNum);

// Output the number the user typed
printf(“Your number is: %d”, myNum);

The scanf() function takes two arguments: the format specifier of the variable (%d in the example above) and the reference operator (&myNum), which stores the memory address of the variable.

Multiple Inputs

The scanf() function also allow multiple inputs (an integer and a character in the following example):

Example

// Create an int and a char variable
int myNum;
char myChar;

// Ask the user to type a number AND a character
printf(“Type a number AND a character and press enter: \n”);

// Get and save the number AND character the user types
scanf(“%d %c”, &myNum, &myChar);

// Print the number
printf(“Your number is: %d\n”, myNum);

// Print the character
printf(“Your character is: %c\n”, myChar);

Take String Input

You can also get a string entered by the user:

Example

Output the name of a user:

// Create a string
char firstName[30];

// Ask the user to input some text
printf(“Enter your first name: \n”);

// Get and save the text
scanf(“%s”, firstName);

// Output the text
printf(“Hello %s”, firstName);

Note: When working with strings in scanf(), you must specify the size of the string/array (we used a very high number, 30 in our example, but atleast then we are certain it will store enough characters for the first name), and you don’t have to use the reference operator (&).

However, the scanf() function has some limitations: it considers space (whitespace, tabs, etc) as a terminating character, which means that it can only display a single word (even if you type many words). For example:

Example

char fullName[30];

printf(“Type your full name: \n”);
scanf(“%s”, &fullName);

printf(“Hello %s”, fullName);

// Type your full name: John Doe
// Hello John

From the example above, you would expect the program to print “John Doe”, but it only prints “John”.

That’s why, when working with strings, we often use the fgets() function to read a line of text. Note that you must include the following arguments: the name of the string variable, sizeof(string_name), and stdin:

Example

char fullName[30];

printf(“Type your full name: \n”);
fgets(fullName, sizeof(fullName), stdin);

printf(“Hello %s”, fullName);

// Type your full name: John Doe
// Hello John Doe

Basics of Memory Addresses in C

When C was created, in 1972, computers were much slower. Most programs were written in assembly. C came along as a better assembly allowing programmers to manipulate memory directly with pointers. Programmers worked much closer to the machine and had to understand how memory worked to make their programs efficient.

Memory Addresses

Memory can be though of as an array of bytes where each address is on index in the array and holds 1 byte. If a computer has 4K of memory, it would have 4096 addresses in the memory array. How operating systems handle memory is much more complex than this, but the analogy provides an easy way to think about memory to get started.

Let’s say our computer has 4K of memory and the next open address is 2048. We declare a new char variable i = ‘a’. When the variable gets declared, enough memory is set aside for its value from unused memory. The variable name is linked to the starting address in memory. Our char i has a value ‘a’ stored at the address 2048. Our char is a single byte so it only takes up index 2048. If we use the & operator on our variable it would return the address 2048. If the variable was a different type, int for instance, it would take up 4 bytes and use up elements 2048-2051 in the array. Using the & would still return 2048 though because the int starts at that index even though it takes up 4 bytes. Let’s look at an example.

// intialize a char variable, print its address and the next address

char charvar = ‘\0’;

printf("address of charvar = %p\n", (void *)(&charvar));

printf("address of charvar – 1 = %p\n", (void *)(&charvar – 1));

printf("address of charvar + 1 = %p\n", (void *)(&charvar + 1));

// intialize an int variable, print its address and the next address

int intvar = 1;

printf("address of intvar = %p\n", (void *)(&intvar));

printf("address of intvar – 1 = %p\n", (void *)(&intvar – 1));

printf("address of intvar + 1 = %p\n", (void *)(&intvar + 1));

Running that you should get output like the following:

address of charvar = 0x7fff9575c05f
address of charvar - 1 = 0x7fff9575c05e
address of charvar + 1 = 0x7fff9575c060
address of intvar = 0x7fff9575c058
address of intvar - 1 = 0x7fff9575c054
address of intvar + 1 = 0x7fff9575c05c

In the first example on lines 1-5 we declare a char variable, print out the address-of the char, and then print out the address just before and just after the char in memory. We get the addresses before and after by getting the using the & operator and then adding or subtracting one. In the second example on lines 7-11 we do the same thing except this time we declare an int variable, printing out its address and the addresses right before and after it.

In the output we see the addresses in hexadecimal. What is important to notice is that the char addresses are 1 byte before and after while the int the addresses are 4 bytes before and after. Math on memory addresses, pointer math, is based on the sizeof the type being referenced. The size of a given type is platform dependent but for this example our char takes 1 byte and our int takes 4 bytes. Subtracting 1 address from a char gives a memory address that is 1 byte previous while subtracting 1 from an int gives a memory address that is 4 bytes previous.

Even though in our example we were using the address-of operator to get the addresses of our variables, the operations are the same when using pointers that hold the address-of a varible.

Some commenters have brought up that storing &charvar – 1, an invalid address because it is before the array, is technically unspecified behavior. This is true. The C standard does have areas that are unspecified and on some platforms even storing an invalid address will cause an error.

Array Addresses

Arrays in C are contiguous memory areas that hold a number of values of the same data type (int, long, *char, etc.). Many programmers when they first use C think arrays are pointers. That isn’t true. A pointer stores a single memory address, an array is a contiguous area of memory that stores multiple values.

// initialize an array of ints

int numbers[5] = {1,2,3,4,5};

int i = 0;

// print the address of the array variable

printf("numbers = %p\n", numbers);

// print addresses of each array index

do {

printf("numbers[%u] = %p\n", i, (void *)(&numbers[i]));

i++;

} while(i < 5);

// print the size of the array

printf("sizeof(numbers) = %lu\n", sizeof(numbers));

Running that you should get output like the following:

numbers = 0x7fff0815c0e0
numbers[0] = 0x7fff0815c0e0
numbers[1] = 0x7fff0815c0e4
numbers[2] = 0x7fff0815c0e8
numbers[3] = 0x7fff0815c0ec
numbers[4] = 0x7fff0815c0f0
sizeof(numbers) = 20

In this example we initialize an array of 5 ints. We then print the address of the array itself. Notice we didn’t use the address-of & operator. This is because the array variable already decays to the address of the first element in the array. As you can see the address of the array and the address of the first element in the array are the same. Then we loop through the array and print out the memory addresses at each index. Each int is 4 bytes on our computer and array memory is contiguous, so each int addres be 4 bytes away from each other.

In the last line we print the size of the array. The size of an array is the sizeof(type) * number of elements in the array. Here the array holds 5 ints, each of which takes up 4 bytes. The entire array is 20 bytes.

Struct Addresses

Structs in C tend to be contiguous memory areas, though not always. And like arrays they hold multiple data types, but unlike arrays they can hold a different data types.

struct measure {

char category;

int width;

int height;

};

// declare and populate the struct

struct measure ball;

ball.category = ‘C’;

ball.width = 5;

ball.height = 3;

// print the addresses of the struct and its members

printf("address of ball = %p\n", (void *)(&ball));

printf("address of ball.category = %p\n", (void *)(&ball.category));

printf("address of ball.width = %p\n", (void *)(&ball.width));

printf("address of ball.height = %p\n", (void *)(&ball.height));

// print the size of the struct

printf("sizeof(ball) = %lu\n", sizeof(ball));

Running that you should get output like the following:

address of ball = 0x7fffd1510060
address of ball.category = 0x7fffd1510060
address of ball.width = 0x7fffd1510064
address of ball.height = 0x7fffd1510068
sizeof(ball) = 12

In this example we have our struct definition. Then we declare a instance ball of the struct measure and we populate its width, height, and category members with values. Then we print out the address of the ball variable. Like the array varible structs decay to the address of their first element. We then print out each of the struct members. Category is the is the first member and we see that it has the same address as the ball variable. The width member is next followed by the height member. Both have address higher than the category member.

You might think that because category is a char and chars take up 1 byte then the width member should be at an address 1 byte higher than the start. As you can see from the output this isn’t the case. According to the C99 standard (C99 §6.7.2.1), a C implementation can add padding bytes to members for aligment on byte boundaries. It cannot reorder the data members but it can add in padding bytes. In practice most compilers will make each member the same size as the largest member in the struct but this is entirely implementatation specific.

In our example you can see that the char actually takes up 4 bytes and the size of the struct takes a total of 12 bytes. What to take away?

A struct variable points to the address of the first member in the struct.
Don’t assume that struct members will be a specific number of bytes away from another field, they may have padding bytes or the memory might not be contiguous depending on the implementation. Use the address-of (&) operator on the member to get its address.
And use sizeof(struct instance) to get the total size of the struct, don’t assume it is just the sum of its member fields, it may have padding.

C – Pointers

Pointers in C are easy and fun to learn. Some C programming tasks are performed more easily with pointers, and other tasks, such as dynamic memory allocation, cannot be performed without using pointers. So it becomes necessary to learn pointers to become a perfect C programmer. Let’s start learning them in simple and easy steps.

As you know, every variable is a memory location and every memory location has its address defined which can be accessed using ampersand (&) operator, which denotes an address in memory. Consider the following example, which prints the address of the variables defined −

#include <stdio.h>

int main () {

   int  var1;
   char var2[10];

   printf("Address of var1 variable: %x\n", &var1  );
   printf("Address of var2 variable: %x\n", &var2  );

   return 0;
}

When the above code is compiled and executed, it produces the following result −

Address of var1 variable: bff5a400
Address of var2 variable: bff5a3f6

What are Pointers?

A pointer is a variable whose value is the address of another variable, i.e., direct address of the memory location. Like any variable or constant, you must declare a pointer before using it to store any variable address. The general form of a pointer variable declaration is −

type *var-name;

Here, type is the pointer’s base type; it must be a valid C data type and var-name is the name of the pointer variable. The asterisk * used to declare a pointer is the same asterisk used for multiplication. However, in this statement the asterisk is being used to designate a variable as a pointer. Take a look at some of the valid pointer declarations −

int    *ip;    /* pointer to an integer */
double *dp;    /* pointer to a double */
float  *fp;    /* pointer to a float */
char   *ch     /* pointer to a character */

The actual data type of the value of all pointers, whether integer, float, character, or otherwise, is the same, a long hexadecimal number that represents a memory address. The only difference between pointers of different data types is the data type of the variable or constant that the pointer points to.

How to Use Pointers?

There are a few important operations, which we will do with the help of pointers very frequently. (a) We define a pointer variable, (b) assign the address of a variable to a pointer and (c) finally access the value at the address available in the pointer variable. This is done by using unary operator * that returns the value of the variable located at the address specified by its operand. The following example makes use of these operations −

#include <stdio.h>

int main () {

   int  var = 20;   /* actual variable declaration */
   int  *ip;        /* pointer variable declaration */

   ip = &var;  /* store address of var in pointer variable*/

   printf("Address of var variable: %x\n", &var  );

   /* address stored in pointer variable */
   printf("Address stored in ip variable: %x\n", ip );

   /* access the value using the pointer */
   printf("Value of *ip variable: %d\n", *ip );

   return 0;
}

When the above code is compiled and executed, it produces the following result −

Address of var variable: bffd8b3c
Address stored in ip variable: bffd8b3c
Value of *ip variable: 20

NULL Pointers

It is always a good practice to assign a NULL value to a pointer variable in case you do not have an exact address to be assigned. This is done at the time of variable declaration. A pointer that is assigned NULL is called a null pointer.

The NULL pointer is a constant with a value of zero defined in several standard libraries. Consider the following program −

#include <stdio.h>

int main () {

   int  *ptr = NULL;

   printf("The value of ptr is : %x\n", ptr  );
 
   return 0;
}

When the above code is compiled and executed, it produces the following result −

The value of ptr is 0

In most of the operating systems, programs are not permitted to access memory at address 0 because that memory is reserved by the operating system. However, the memory address 0 has special significance; it signals that the pointer is not intended to point to an accessible memory location. But by convention, if a pointer contains the null (zero) value, it is assumed to point to nothing.

To check for a null pointer, you can use an ‘if’ statement as follows −

if(ptr)     /* succeeds if p is not null */
if(!ptr)    /* succeeds if p is null */

Pointers in Detail

Pointers have many but easy concepts and they are very important to C programming. The following important pointer concepts should be clear to any C programmer −

Sr.No.	Concept & Description
1	Pointer arithmetic There are four arithmetic operators that can be used in pointers: ++, –, +, –
2	Array of pointers You can define arrays to hold a number of pointers.
3	Pointer to pointer C allows you to have pointer on a pointer and so on.
4	Passing pointers to functions in C Passing an argument by reference or by address enable the passed argument to be changed in the calling function by the called function.
5	Return pointer from functions in C C allows a function to return a pointer to the local variable, static variable, and dynamically allocated memory as well.

C Functions

In c, we can divide a large program into the basic building blocks known as function. The function contains the set of programming statements enclosed by {}. A function can be called multiple times to provide reusability and modularity to the C program. In other words, we can say that the collection of functions creates a program. The function is also known as procedureor subroutinein other programming languages.

Advantage of functions in C

There are the following advantages of C functions.

By using functions, we can avoid rewriting same logic/code again and again in a program.
We can call C functions any number of times in a program and from any place in a program.
We can track a large C program easily when it is divided into multiple functions.
Reusability is the main achievement of C functions.
However, Function calling is always a overhead in a C program.

Function Aspects

There are three aspects of a C function.

- Function declaration A function must be declared globally in a c program to tell the compiler about the function name, function parameters, and return type.

- Function call Function can be called from anywhere in the program. The parameter list must not differ in function calling and function declaration. We must pass the same number of functions as it is declared in the function declaration.

- Function definition It contains the actual statements which are to be executed. It is the most important aspect to which the control comes when the function is called. Here, we must notice that only one value can be returned from the function.

SN	C function aspects	Syntax
1	Function declaration	return_type function_name (argument list);
2	Function call	function_name (argument_list)
3	Function definition	return_type function_name (argument list) {function body;}

The syntax of creating function in c language is given below:

return_type function_name(data_type parameter…){  
//code to be executed  
}  

Types of Functions

There are two types of functions in C programming:

Library Functions: are the functions which are declared in the C header files such as scanf(), printf(), gets(), puts(), ceil(), floor() etc.
User-defined functions: are the functions which are created by the C programmer, so that he/she can use it many times. It reduces the complexity of a big program and optimizes the code.

Return Value

A C function may or may not return a value from the function. If you don’t have to return any value from the function, use void for the return type.

Let’s see a simple example of C function that doesn’t return any value from the function.

Example without return value:

 
void hello(){  
printf(“hello c”);  
}  

If you want to return any value from the function, you need to use any data type such as int, long, char, etc. The return type depends on the value to be returned from the function.

Let’s see a simple example of C function that returns int value from the function.

Example with return value:

int get(){  
return 10;  
}  

In the above example, we have to return 10 as a value, so the return type is int. If you want to return floating-point value (e.g., 10.2, 3.1, 54.5, etc), you need to use float as the return type of the method.

float get(){  
return 10.2;  
}  

Now, you need to call the function, to get the value of the function.

Different aspects of function calling

A function may or may not accept any argument. It may or may not return any value. Based on these facts, There are four different aspects of function calls.

function without arguments and without return value
function without arguments and with return value
function with arguments and without return value
function with arguments and with return value

Example for Function without argument and return value

Example 1

#include<stdio.h>  
void printName();  
void main ()  
{  
    printf(“Hello “);  
    printName();  
}  
void printName()  
{  
    printf(“prathamguru”);  
}  

Output

Hello prathamguru

Example 2

#include<stdio.h>  
void sum();  
void main()  
{  
    printf(“\nGoing to calculate the sum of two numbers:”);  
    sum();  
}  
void sum()  
{  
    int a,b;   
    printf(“\nEnter two numbers”);  
    scanf(“%d %d”,&a,&b);   
    printf(“The sum is %d”,a+b);  
}  

Output

Going to calculate the sum of two numbers:

Enter two numbers 10 
24 

The sum is 34

Example for Function without argument and with return value

Example 1

#include<stdio.h>  
int sum();  
void main()  
{  
    int result;   
    printf(“\nGoing to calculate the sum of two numbers:”);  
    result = sum();  
    printf(“%d”,result);  
}  
int sum()  
{  
    int a,b;   
    printf(“\nEnter two numbers”);  
    scanf(“%d %d”,&a,&b);  
    return a+b;   
}  

Output

Going to calculate the sum of two numbers:

Enter two numbers 10 
24 

The sum is 34

Example 2: program to calculate the area of the square

#include<stdio.h>  
int sum();  
void main()  
{  
    printf(“Going to calculate the area of the square\n”);  
    float area = square();  
    printf(“The area of the square: %f\n”,area);  
}  
int square()  
{  
    float side;  
    printf(“Enter the length of the side in meters: “);  
    scanf(“%f”,&side);  
    return side * side;  
}  

Output

Going to calculate the area of the square 
Enter the length of the side in meters: 10 
The area of the square: 100.000000

Example for Function with argument and without return value

Example 1

#include<stdio.h>  
void sum(int, int);  
void main()  
{  
    int a,b,result;   
    printf(“\nGoing to calculate the sum of two numbers:”);  
    printf(“\nEnter two numbers:”);  
    scanf(“%d %d”,&a,&b);  
    sum(a,b);  
}  
void sum(int a, int b)  
{  
    printf(“\nThe sum is %d”,a+b);      
}  

Output

Going to calculate the sum of two numbers:

Enter two numbers 10 
24 

The sum is 34

Example 2: program to calculate the average of five numbers.

#include<stdio.h>  
void average(int, int, int, int, int);  
void main()  
{  
    int a,b,c,d,e;   
    printf(“\nGoing to calculate the average of five numbers:”);  
    printf(“\nEnter five numbers:”);  
    scanf(“%d %d %d %d %d”,&a,&b,&c,&d,&e);  
    average(a,b,c,d,e);  
}  
void average(int a, int b, int c, int d, int e)  
{  
    float avg;   
    avg = (a+b+c+d+e)/5;   
    printf(“The average of given five numbers : %f”,avg);  
}  

Output

Going to calculate the average of five numbers:
Enter five numbers:10 
20
30
40
50
The average of given five numbers : 30.000000

Example for Function with argument and with return value

Example 1

#include<stdio.h>  
int sum(int, int);  
void main()  
{  
    int a,b,result;   
    printf(“\nGoing to calculate the sum of two numbers:”);  
    printf(“\nEnter two numbers:”);  
    scanf(“%d %d”,&a,&b);  
    result = sum(a,b);  
    printf(“\nThe sum is : %d”,result);  
}  
int sum(int a, int b)  
{  
    return a+b;  
}  

Output

Going to calculate the sum of two numbers:
Enter two numbers:10
20 
The sum is : 30

Example 2: Program to check whether a number is even or odd

#include<stdio.h>  
int even_odd(int);  
void main()  
{  
 int n,flag=0;  
 printf(“\nGoing to check whether a number is even or odd”);  
 printf(“\nEnter the number: “);  
 scanf(“%d”,&n);  
 flag = even_odd(n);  
 if(flag == 0)  
 {  
    printf(“\nThe number is odd”);  
 }  
 else   
 {  
    printf(“\nThe number is even”);  
 }  
}  
int even_odd(int n)  
{  
    if(n%2 == 0)  
    {  
        return 1;  
   }  
    else   
    {  
        return 0;  
    }  
}  

Output

Going to check whether a number is even or odd
Enter the number: 100
The number is even

C Library Functions

Library functions are the inbuilt function in C that are grouped and placed at a common place called the library. Such functions are used to perform some specific operations. For example, printf is a library function used to print on the console. The library functions are created by the designers of compilers. All C standard library functions are defined inside the different header files saved with the extension .h. We need to include these header files in our program to make use of the library functions defined in such header files. For example, To use the library functions such as printf/scanf we need to include stdio.h in our program which is a header file that contains all the library functions regarding standard input/output.

The list of mostly used header files is given in the following table.

SN	Header file	Description
1	stdio.h	This is a standard input/output header file. It contains all the library functions regarding standard input/output.
2	conio.h	This is a console input/output header file.
3	string.h	It contains all string related library functions like gets(), puts(),etc.
4	stdlib.h	This header file contains all the general library functions like malloc(), calloc(), exit(), etc.
5	math.h	This header file contains all the math operations related functions like sqrt(), pow(), etc.
6	time.h	This header file contains all the time-related functions.
7	ctype.h	This header file contains all character handling functions.
8	stdarg.h	Variable argument functions are defined in this header file.
9	signal.h	All the signal handling functions are defined in this header file.
10	setjmp.h	This file contains all the jump functions.
11	locale.h	This file contains locale functions.
12	errno.h	This file contains error handling functions.
13	assert.h	This file contains diagnostics functions.

Function Declaration and Definition

You just learned from the previous chapters that you can create and call a function in the following way:

Example

// Create a function
void myFunction() {
printf(“I just got executed!”);
}

int main() {
myFunction(); // call the function
return 0;
}

A function consist of two parts:

Declaration: the function’s name, return type, and parameters (if any)
Definition: the body of the function (code to be executed)

void myFunction() { // declaration
// the body of the function (definition)
}

For code optimization, it is recommended to separate the declaration and the definition of the function.

You will often see C programs that have function declaration above main(), and function definition below main(). This will make the code better organized and easier to read:

Example

// Function declaration
void myFunction();

// The main method
int main() {
myFunction(); // call the function
return 0;
}

// Function definition
void myFunction() {
printf(“I just got executed!”);
}

Another Example

If we use the example from the previous chapter regarding function parameters and return values:

Example

int myFunction(int x, int y) {
return x + y;
}

int main() {
int result = myFunction(5, 3);
printf(“Result is = %d”, result);
return 0;
}
// Outputs 8 (5 + 3)

It is considered good practice to write it like this instead:

Example

// Function declaration
int myFunction(int, int);

// The main method
int main() {
  int result = myFunction(5, 3); // call the function
  printf(“Result is = %d”, result);
  return 0;
}

// Function definition
int myFunction(int x, int y) {
return x + y;
}

Recursion in C

Recursion is the process which comes into existence when a function calls a copy of itself to work on a smaller problem. Any function which calls itself is called recursive function, and such function calls are called recursive calls. Recursion involves several numbers of recursive calls. However, it is important to impose a termination condition of recursion. Recursion code is shorter than iterative code however it is difficult to understand.

Recursion cannot be applied to all the problem, but it is more useful for the tasks that can be defined in terms of similar subtasks. For Example, recursion may be applied to sorting, searching, and traversal problems.

Generally, iterative solutions are more efficient than recursion since function call is always overhead. Any problem that can be solved recursively, can also be solved iteratively. However, some problems are best suited to be solved by the recursion, for example, tower of Hanoi, Fibonacci series, factorial finding, etc.

In the following example, recursion is used to calculate the factorial of a number.

#include <stdio.h>  
int fact (int);  
int main()  
{  
    int n,f;  
    printf(“Enter the number whose factorial you want to calculate?”);  
    scanf(“%d”,&n);  
    f = fact(n);  
    printf(“factorial = %d”,f);  
}  
int fact(int n)  
{  
    if (n==0)  
    {  
        return 0;  
    }  
    else if ( n == 1)  
    {  
        return 1;  
    }  
    else   
    {  
        return n*fact(n-1);  
    }  
}  

Output

Enter the number whose factorial you want to calculate?5

factorial = 120

Recursive Function

A recursive function performs the tasks by dividing it into the subtasks. There is a termination condition defined in the function which is satisfied by some specific subtask. After this, the recursion stops and the final result is returned from the function.

The case at which the function doesn’t recur is called the base case whereas the instances where the function keeps calling itself to perform a subtask, is called the recursive case. All the recursive functions can be written using this format.

Pseudocode for writing any recursive function is given below.

 
if (test_for_base)  
{  
    return some_value;  
}  
else if (test_for_another_base)  
{  
    return some_another_value;  
}  
else  
{  
    // Statements;  
    recursive call;  
}  

Example of recursion in C

Let’s see an example to find the nth term of the Fibonacci series.

 
#include<stdio.h>  
int fibonacci(int);  
void main ()  
{  
    int n,f;  
    printf(“Enter the value of n?”);  
    scanf(“%d”,&n);  
    f = fibonacci(n);  
    printf(“%d”,f);  
}  
int fibonacci (int n)  
{  
    if (n==0)  
    {  
    return 0;  
    }  
    else if (n == 1)  
    {  
        return 1;   
    }  
    else  
    {  
        return fibonacci(n-1)+fibonacci(n-2);  
    }  
}  

Output

Enter the value of n?12 
144

Memory allocation of Recursive method

Each recursive call creates a new copy of that method in the memory. Once some data is returned by the method, the copy is removed from the memory. Since all the variables and other stuff declared inside function get stored in the stack, therefore a separate stack is maintained at each recursive call. Once the value is returned from the corresponding function, the stack gets destroyed. Recursion involves so much complexity in resolving and tracking the values at each recursive call. Therefore we need to maintain the stack and track the values of the variables defined in the stack.

Let us consider the following example to understand the memory allocation of the recursive functions.

 
int display (int n)  
{  
    if(n == 0)  
        return 0; // terminating condition  
    else   
    {  
        printf(“%d”,n);  
        return display(n-1); // recursive call  
    }  
}  

Explanation

Let us examine this recursive function for n = 4. First, all the stacks are maintained which prints the corresponding value of n until n becomes 0, Once the termination condition is reached, the stacks get destroyed one by one by returning 0 to its calling stack. Consider the following image for more information regarding the stack trace for the recursive functions.

Math Functions

There is also a list of math functions available, that allows you to perform mathematical tasks on numbers.

To use them, you must include the math.h header file in your program:

#include <math.h>

Square Root

To find the square root of a number, use the sqrt() function:

Example

printf(“%f”, sqrt(16));

Try it Yourself »

Round a Number

The ceil() function rounds a number upwards to its nearest integer, and the floor() method rounds a number downwards to its nearest integer, and returns the result:

Example

printf(“%f”, ceil(1.4));
printf(“%f”, floor(1.4));

Try it Yourself »

Power

The pow() function returns the value of x to the power of y (x^y):

Example

printf(“%f”, pow(4, 3));

Other Math Functions

A list of other popular math functions (from the <math.h> library) can be found in the table below:

Function	Description
abs(x)	Returns the absolute value of x
acos(x)	Returns the arccosine of x
asin(x)	Returns the arcsine of x
atan(x)	Returns the arctangent of x
cbrt(x)	Returns the cube root of x
cos(x)	Returns the cosine of x
exp(x)	Returns the value of E^x
sin(x)	Returns the sine of x (x is in radians)
tan(x)	Returns the tangent of an angle

File Handling

In C, you can create, open, read, and write to files by declaring a pointer of type FILE, and use the fopen() function:

FILE *fptr
fptr = fopen(filename, mode);

FILE is basically a data type, and we need to create a pointer variable to work with it (fptr). For now, this line is not important. It’s just something you need when working with files.

To actually open a file, use the fopen() function, which takes two parameters:

Parameter Description

filename The name of the actual file you want to open (or create), like filename.txt

Parameter	Description
filename	The name of the actual file you want to open (or create), like `filename.txt`
mode	A single character, which represents what you want to do with the file (read, write or append): `w` – Writes to a file `a` – Appends new data to a file `r` – Reads from a file

mode

A single character, which represents what you want to do with the file (read, write or append):

w – Writes to a file
a – Appends new data to a file
r – Reads from a file

Create a File

To create a file, you can use the w mode inside the fopen() function.

The w mode is used to write to a file. However, if the file does not exist, it will create one for you:

Example

FILE *fptr;

// Create a file
fptr = fopen(“filename.txt”, “w”);

// Close the file
fclose(fptr);

On our computer, it looks like this:

Tip: If you want to create the file in a specific folder, just provide an absolute path:

fptr = fopen(“C:\directoryname\filename.txt”, “w”);

Write To a File

Let’s use the w mode from the previous chapter again, and write something to the file we just created.

The w mode means that the file is opened for writing. To insert content to it, you can use the fprint() function and add the pointer variable (fptr in our example) and some text:

Example

FILE *fptr;

// Open a file in writing mode
fptr = fopen(“filename.txt”, “w”);

// Write some text to the file
fprintf(fptr, “Some text”);

// Close the file
fclose(fptr);

As a result, when we open the file on our computer, it looks like this:

Note: If you write to a file that already exists, the old content is deleted, and the new content is inserted. This is important to know, as you might accidentally erase existing content.

For example:

Example

fprintf(fptr, “Hello World!”);

As a result, when we open the file on our computer, it says “Hello World!” instead of “Some text”:

Append Content To a File

If you want to add content to a file without deleting the old content, you can use the a mode.

The a mode appends content at the end of the file:

Example

FILE *fptr;

// Open a file in append mode
fptr = fopen(“filename.txt”, “a”);

// Append some text to the file
fprintf(fptr, “\nHi everybody!”);

// Close the file
fclose(fptr);

As a result, when we open the file on our computer, it looks like this:

Starting Course

Introduction to Excel

2 Hrs.

Engine Target Audience

Quiz: Mobile / Native Apps

18 questions

Introduction to Excel

2 Hrs.

After Intro

Realistic Graphic on UE4

Volta GPU for optimization.

Deep Learning

FAQ 1

Faq Content 1

FAQ 2

Faq Content 2

Productivity Hacks to Get More Done in 2018

— 28 February 2017

Facebook News Feed Eradicator (free chrome extension) Stay focused by removing your Facebook newsfeed and replacing it with an inspirational quote. Disable the tool anytime you want to see what friends are up to!
Hide My Inbox (free chrome extension for Gmail) Stay focused by hiding your inbox. Click "show your inbox" at a scheduled time and batch processs everything one go.
Habitica (free mobile + web app) Gamify your to do list. Treat your life like a game and earn gold goins for getting stuff done!

4 out of 5

6 Ratings

Detailed Rating

Stars 5		3
Stars 4		0
Stars 3		3
Stars 2		0
Stars 1		0

Please, login to leave a review

Add to Wishlist

Enroll course

Enrolled: 36 students

Duration: 10 hours

Lectures: 6

Video: 9 hours

Level: Advanced

Working hours

Monday	9:30 am - 6.00 pm
Tuesday	9:30 am - 6.00 pm
Wednesday	9:30 am - 6.00 pm
Thursday	9:30 am - 6.00 pm
Friday	9:30 am - 5.00 pm
Saturday	Closed
Sunday	Closed

C / C++ / DBA

Learn Let us C Learn C++

Algorithm In C Language

Analysis Of Algorithm in C++

Where is C used?

How does the C programming language work?

Variable Definition in C

Variable Declaration in C

Example

Lvalues and Rvalues in C

Data types

Data Types in C

Primary Data Types in C Programming

Character (char):

Integer (int):

Floating-point (float):

Double (double):

Void (void):

Size of different Datatypes in C

1. char is 1 byte

2. int can be 2 bytes/4 bytes

3. float is 4 bytes

4. double is 8 bytes

5. void is 0 bytes

C Data type Modifiers:

C Data type Value Range

What happens if the value is out of Range?

What does signed and unsigned means?

Derived Data types in C

Operators

Example

int myNum = 100 + 50;

Example

Arithmetic Operators

Assignment Operators

Example

int x = 10;

Example

Comparison Operators

Example

Logical Operators

Sizeof Operator

Example

Booleans

Boolean Variables

Example

Comparing Values and Variables

Example

Example

Example

Example

Real Life Example

Example

Example

Conditions and If Statements

The if Statement

Syntax

Example

Example

Example explained

The else Statement

Syntax

Example

Example explained

The else if Statement

Syntax

Example

example explained

In the example above, time (22) is greater than 10, so the first condition is false. The next condition, in the else if statement, is also false, so we move on to the else condition since condition1 and condition2 is both false – and print to the screen “Good evening”.

Another Example

Example

Short Hand If…Else (Ternary Operator)

Syntax

Example

Example

C switch Statement

Syntax of switch…case

switch Statement Flowchart

Example: Simple Calculator

C while loop

Character (`char`):

Integer (`int`):

Floating-point (`float`):

Double (`double`):

Void (`void`):

What does `signed` and `unsigned` means?

In the example above, time (22) is greater than 10, so the first condition is `false`. The next condition, in the `else if` statement, is also `false`, so we move on to the `else` condition since condition1 and condition2 is both `false` – and print to the screen “Good evening”.