assignment program in c

• C Programming Tutorial
• C - Overview
• C - Features
• C - History
• C - Environment Setup
• C - Program Structure
• C - Hello World
• C - Compilation Process
• C - Comments
• C - Keywords
• C - Identifiers
• C - User Input
• C - Basic Syntax
• C - Data Types
• C - Variables
• C - Integer Promotions
• C - Type Conversion
• C - Booleans
• C - Constants
• C - Literals
• C - Escape sequences
• C - Format Specifiers
• C - Storage Classes
• C - Operators
• C - Arithmetic Operators
• C - Relational Operators
• C - Logical Operators
• C - Bitwise Operators
• C - Assignment Operators
• C - Unary Operators
• C - Increment and Decrement Operators
• C - Ternary Operator
• C - sizeof Operator
• C - Operator Precedence
• C - Misc Operators
• C - Decision Making
• C - if statement
• C - if...else statement
• C - nested if statements
• C - switch statement
• C - nested switch statements
• C - While loop
• C - For loop
• C - Do...while loop
• C - Nested loop
• C - Infinite loop
• C - Break Statement
• C - Continue Statement
• C - goto Statement
• C - Functions
• C - Main Functions
• C - Function call by Value
• C - Function call by reference
• C - Nested Functions
• C - Variadic Functions
• C - User-Defined Functions
• C - Callback Function
• C - Return Statement
• C - Recursion
• C - Scope Rules
• C - Static Variables
• C - Global Variables
• C - Properties of Array
• C - Multi-Dimensional Arrays
• C - Passing Arrays to Function
• C - Return Array from Function
• C - Variable Length Arrays
• C - Pointers
• C - Pointers and Arrays
• C - Applications of Pointers
• C - Pointer Arithmetics
• C - Array of Pointers
• C - Pointer to Pointer
• C - Passing Pointers to Functions
• C - Return Pointer from Functions
• C - Function Pointers
• C - Pointer to an Array
• C - Pointers to Structures
• C - Chain of Pointers
• C - Pointer vs Array
• C - Character Pointers and Functions
• C - NULL Pointer
• C - void Pointer
• C - Dangling Pointers
• C - Dereference Pointer
• C - Near, Far and Huge Pointers
• C - Initialization of Pointer Arrays
• C - Pointers vs. Multi-dimensional Arrays
• C - Strings
• C - Array of Strings
• C - Special Characters
• C - Structures
• C - Structures and Functions
• C - Arrays of Structures
• C - Self-Referential Structures
• C - Lookup Tables
• C - Dot (.) Operator
• C - Enumeration (or enum)
• C - Nested Structures
• C - Structure Padding and Packing
• C - Anonymous Structure and Union
• C - Bit Fields
• C - Typedef
• C - Input & Output
• C - File I/O
• C - Preprocessors
• C - Header Files
• C - Type Casting
• C - Error Handling
• C - Variable Arguments
• C - Memory Management
• C - Command Line Arguments
• C Programming Resources
• C - Questions & Answers
• C - Quick Guide
• C - Useful Resources
• C - Discussion
• Selected Reading
• UPSC IAS Exams Notes
• Developer's Best Practices
• Questions and Answers
• Effective Resume Writing
• HR Interview Questions
• Computer Glossary

Assignment Operators in C

In C language, the assignment operator stores a certain value in an already declared variable. A variable in C can be assigned the value in the form of a literal, another variable, or an expression.

The value to be assigned forms the right-hand operand, whereas the variable to be assigned should be the operand to the left of the " = " symbol, which is defined as a simple assignment operator in C.

In addition, C has several augmented assignment operators.

The following table lists the assignment operators supported by the C language −

Simple Assignment Operator (=)

The = operator is one of the most frequently used operators in C. As per the ANSI C standard, all the variables must be declared in the beginning. Variable declaration after the first processing statement is not allowed.

You can declare a variable to be assigned a value later in the code, or you can initialize it at the time of declaration.

You can use a literal, another variable, or an expression in the assignment statement.

Once a variable of a certain type is declared, it cannot be assigned a value of any other type. In such a case the C compiler reports a type mismatch error.

In C, the expressions that refer to a memory location are called "lvalue" expressions. A lvalue may appear as either the left-hand or right-hand side of an assignment.

On the other hand, the term rvalue refers to a data value that is stored at some address in memory. A 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 −

Augmented Assignment Operators

In addition to the = operator, C allows you to combine arithmetic and bitwise operators with the = symbol to form augmented or compound assignment operator. The augmented operators offer a convenient shortcut for combining arithmetic or bitwise operation with assignment.

For example, the expression "a += b" has the same effect of performing "a + b" first and then assigning the result back to the variable "a".

Run the code and check its output −

Similarly, the expression "a <<= b" has the same effect of performing "a << b" first and then assigning the result back to the variable "a".

Here is a C program that demonstrates the use of assignment operators in C −

When you compile and execute the above program, it will produce the following result −

To Continue Learning Please Login

The C Programming Handbook for Beginners

C is one of the oldest, most widely known, and most influential programming languages.

It is used in many industries because it is a highly flexible and powerful language.

Learning C is a worthwhile endeavor – no matter your starting point or aspirations – because it builds a solid foundation in the skills you will need for the rest of your programming career.

It helps you understand how a computer works underneath the hood, such as how it stores and retrieves information and what the internal architecture looks like.

With that said, C can be a difficult language to learn, especially for beginners, as it can be cryptic.

This handbook aims to teach you C programming fundamentals and is written with the beginner programmer in mind.

There are no prerequisites, and no previous knowledge of any programming concepts is assumed.

If you have never programmed before and are a complete beginner, you have come to the right place.

Here is what you are going to learn in this handbook:

Chapter 1: Introduction to C Programming

• Chapter 2: Variables and Data Types in C
• Chapter 3: Operators in C
• Chapter 4: Conditional Statements in C
• Chapter 5: Loops in C
• Chapter 6: Arrays in C
• Chapter 7: Strings in C

Further learning: Advanced C Topics

Without further ado, let’s get started with learning C!

In this introductory chapter, you will learn the main characteristics and use cases of the C programming language.

You will also learn the basics of C syntax and familiarize yourself with the general structure of all C programs.

By the end of the chapter, you will have set up a development environment for C programming so you can follow along with the coding examples in this book on your local machine.

You will have successfully written, compiled, and executed your first simple C program that prints the text "Hello, world!" to the screen.

You will have also learned some core C language features, such as comments for documenting and explaining your code and escape sequences for representing nonprintable characters in text.

What Is Programming?

Computers are not that smart.

Even though they can process data tirelessly and can perform operations at a very high speed, they cannot think for themselves. They need someone to tell them what to do next.

Humans tell computers what to do and exactly how to do it by giving them detailed and step-by-step instructions to follow.

A collection of detailed instructions is known as a program.

Programming is the process of writing the collection of instructions that a computer can understand and execute to perform a specific task and solve a particular problem.

A programming language is used to write the instructions.

And the humans who write the instructions and supply them to the computer are known as programmers.

Low-level VS High-Level VS Middle-level Programming Languages – What's The Difference?

There are three types of programming languages: low-level languages, high-level languages, and middle-level languages.

Low-level languages include machine language (also known as binary) and assembly language.

Both languages provide little to no abstraction from the computer's hardware. The language instructions are closely related to or correspond directly to specific machine instructions.

This 'closeness to the machine' allows for speed, efficiency, less consumption of memory, and fine-grained control over the computer's hardware.

Machine language is the lowest level of programming languages.

The instructions consist of series of 0 s and 1 s that correspond directly to a particular computer’s instructions and locations memory.

Instructions are also directly executed by the computer’s processor.

Even though machine language was the language of choice for writing programs in the early days of computing, it is not a human-readable language and is time-consuming to write.

Assembly language allows the programmer to work closely with the machine on a slightly higher level.

It uses mnemonics and symbols that correspond directly to a particular machine’s instruction set instead of using sequences of 0 s and 1 s.

Next, high-level languages, like Python and JavaScript, are far removed from the instruction set of a particular machine architecture.

Their syntax resembles the English language, making them easier to work with and understand.

Programs written in high-level languages are also portable and machine-independent. That is, a program can run on any system that supports that language.

With that said, they tend to be slower, consume more memory, and make it harder to work with low-level hardware and systems because of how abstract they are.

Lastly, middle-level languages, like C and C++, act as a bridge between low-level and high-level programming languages.

They allow for closeness and a level of control over computer hardware. At the same time, they also offer a level of abstraction with instructions that are more human-readable and understandable for programmers to write.

What Is the C Programming Language?

C is a general-purpose and procedural programming language.

A procedural language is a type of programming language that follows a step-by-step approach to solving a problem.

It uses a series of instructions, otherwise known as procedures or functions, that are executed in a specific order to perform tasks and accomplish goals. These intructions tell the computer step by step what to do and in what order.

So, C programs are divided into smaller, more specific functions that accomplish a certain task and get executed sequentially, one after another, following a top-down approach.

This promotes code readability and maintainability.

A Brief History of the C Programming Language

C was developed in the early 1970s by Dennis Ritchie at AT&T Bell Laboratories.

The development of C was closely tied to the development of the Unix operating system at Bell Labs.

Historically, operating systems were typically written in Assembly language and without portability in mind.

During the development of Unix, there was a need for a more efficient and portable programming language for writing operating systems.

Dennis Ritchie went on to create a language called B, which was an evolution from an earlier language called BCPL (Basic Combined Programming Language).

It aimed to bridge the gap between the low-level capabilities of Assembly and the high-level languages used at the time, such as Fortran.

B was not powerful enough to support Unix development, so Dennis Ritchie developed a new language that took inspiration from B and BCPL and had some additional features. He named this language C.

C’s simple design, speed, efficiency, performance, and close relationship with a computer’s hardware made it an attractive choice for systems programming. This led to the Unix operating system being rewritten in C.

C Language Characteristics and Use Cases

Despite C being a relatively old language (compared to other, more modern, programming languages in use today), it has stood the test of time and still remains popular.

According to the TIOBE index , which measures the popularity of programming languages each month, C is the second most popular programming language as of August 2023.

This is because C is considered the "mother of programming languages" and is one of the most foundational languages of computer science.

Most modern and popular languages used today either use C under the hood or are inspired by it.

For example, Python’s default implementation and interpreter, CPython, is written in C. And languages such as C++ and C# are extensions of C and provide additional functionality.

Even though C was originally designed with systems programming in mind, it is widely used in many other areas of computing.

C programs are portable and easy to implement, meaning they can be executed across different platforms with minimal changes.

C also allows for efficient and direct memory manipulation and management, making it an ideal language for performance-critical applications.

And C provides higher-level abstractions along with low-level capabilities, which allows programmers to have fine-grained control over hardware resources when they need to.

These characteristics make C an ideal language for creating operating systems, embedded systems, system utilities, Internet of things (IoT) devices, database systems, and various other applications.

C is used pretty much everywhere today.

How to Set Up a Development Environment for C Programming on Your Local Machine

To start writing C programs on your local machine, you will need the following:

• A C Compiler
• An Integrated Development Environment (IDE)

C is a compiled programming language, like Go, Java, Swift, and Rust.

Compiled languages are different from interpeted languages, such as PHP, Ruby, Python, and JavaScript.

The difference between compiled and interpeted languages is that a compiled language is directly translated to machine code all at once.

This process is done by a special program called a compiler.

The compiler reads the entire source code, checks it for errors, and then translates the entire program into machine code. This is a language the computer can understand and it's directly associated with the particular instructions of the computer.

This process creates a standalone binary executable file containing sequences of 0 s and 1 s which is a more computer-friendly form of the initial source code. This file contains instructions that the computer can understand and run directly.

An interpeted language, on the other hand, doesn’t get translated into machine code all at once and doesn’t produce a binary executable file.

Instead, an interpreter reads and executes the source code one instruction at a time, line by line. The interpreter reads each line, translates it into machine code, and then immediately runs it.

If you are using a Unix or a Unix-like system such as macOS or Linux, you probably have the popular GNU Compiler Collection (GCC) already installed on your machine.

If you are running either of those operating systems, open the terminal application and type the following command:

If you're using macOS and have not installed the command line developer tools, a dialog box will pop-up asking you to install them – so if you see that, go ahead and do so.

If you have already installed the command line tools, you will see an output with the version of the compiler, which will look similar to the following:

If you are using Windows, you can check out Code::Blocks or look into installing Linux on Windows with WSL . Feel free to pick whatever programming environment works best for you.

An IDE is where you write, edit, save, run, and debug your C programs. You can think of it like a word processor but for writing code.

Visual Studio Code is a great editor for writing code, and offers many IDE-like features.

It is free, open-source, supports many programming languages, and is available for all operating systems.

Once you have downloaded Visual Studio Code, install the C/C++ extension .

It’s also a good idea to enable auto-saving by selecting: "File" -> "Auto Save".

If you want to learn more, you can look through the Visual Studio Code documentation for C/C++ .

With your local machine all set up, you are ready to write your first C program!

How to Write Your First C Program

To get started, open Visual Studio Code and create a new folder for your C program by navigating to "File" -> "Open" -> "New Folder".

Give this folder a name, for example, c-practice , and then select "Create" -> “Open".

You should now have the c-practice folder open in Visual Studio Code.

Inside the folder you just created, create a new C file.

Hold down the Command key and press N on macOS or hold down the Control and press N for Windows/Linux to create an Untitled-1 file.

Hold down the Command key and press S on macOS or hold down the Control key and press S for Windows/Linux, and save the file as a main.c file.

Finally, click "Save".

Make sure that you save the file you created with a .c extension, or it won’t be a valid C file.

You should now have the main.c file you just created open in Visual Studio Code.

Next, add the following code:

Let’s go over each line and explain what is happening in the program.

What Are Header Files in C?

Let’s start with the first line, #include <stdio.h> .

The #include part of #include <stdio.h> is a preprocessor command that tells the C compiler to include a file.

Specifically, it tells the compiler to include the stdio.h header file.

Header files are external libraries.

This means that some developers have written some functionality and features that are not included at the core of the C language.

By adding header files to your code, you get additional functionality that you can use in your programs without having to write the code from scratch.

The stdio.h header file stands for standard input-output.

It contains function definitions for input and output operations, such as functions for gathering user data and printing data to the console.

Specifically, it provides functions such as printf() and scanf() .

So, this line is necessary for the function we have later on in our program, printf() , to work.

If you don't include the stdio.h file at the top of your code, the compiler will not understand what the printf() function is.

What is the main() function in C?

Next, int main(void) {} is the main function and starting point of every C program.

It is the first thing that is called when the program is executed.

Every C program must include a main() function.

The int keyword in int main(void) {} indicates the return value of the main() function.

In this case, the function will return an integer number.

And the void keyword inside the main() function indicates that the function receives no arguments.

Anything inside the curly braces, {} , is considered the body of the function – here is where you include the code you want to write. Any code written here will always run first.

This line acts as a boilerplate and starting point for all C programs. It lets the computer know where to begin reading the code when it executes your programs.

What Are Comments in C?

In C programming, comments are lines of text that get ignored by the compiler.

Writing comments is a way to provide additional information and describe the logic, purpose, and functionality of your code.

Comments provide a way to document your code and make it more readable and understandable for anyone who will read and work with it.

Having comments in your source code is also helpful for your future self. So when you come back to the code in a few months and don't remember how the code works, these comments can help.

Comments are also helpful for debugging and troubleshooting. You can temporarily comment out lines of code to isolate problems.

This will allow you to ignore a section of code and concentrate on the piece of code you are testing and working on without having to delete anything.

There are two types of comments in C:

• Single-line comments
• Multi-line comments

Single-line comments start with two forward slashes, // , and continue until the end of the line.

Here is the syntax for creating a single-line comment in C:

Any text written after the forward slashes and on the same line gets ignored by the compiler.

Multi-line comments start with a forward slash, / , followed by an asterisk, * , and end with an asterisk, followed by a forward slash.

As the name suggests, they span multiple lines.

They offer a way to write slightly longer explanations or notes within your code and explain in more detail how it works.

Here is the syntax for creating a multi-line comment in C:

What is the printf() function in C?

Inside the function's body, the line printf("Hello, World!\n"); prints the text Hello, World! to the console (this text is also known as a string).

Whenever you want to display something, use the printf() function.

Surround the text you want to display in double quotation marks, "" , and make sure it is inside the parentheses of the printf() function.

The semicolon, ; , terminates the statement. All statements need to end with a semicolon in C, as it identifies the end of the statement.

You can think of a semicolon similar to how a full stop/period ends a sentence.

What Are Escape Sequences in C?

Did you notice the \n at the end of printf("Hello, World!\n"); ?

It's called an escape sequence, which means that it is a character that creates a newline and tells the cursor to move to the next line when it sees it.

In programming, an escape sequence is a combination of characters that represents a special character within a string.

They provide a way to include special characters that are difficult to represent directly in a string.

They consist of a backslash, \ , also known as the escape character, followed by one or more additional characters.

The escape sequence for a newline character is \n .

Another escape sequence is \t . The \t represrents a tab character, and will insert a space within a string.

How to Compile and Run Your first C Program

In the previous section, you wrote your first C program:

Any code you write in the C programming language is called source code.

Your computer doesn’t understand any of the C statements you have written, so this source code needs to be translated into a different format that the computer can understand. Here is where the compiler you installed earlier comes in handy.

The compiler will read the program and translate it into a format closer to the computer’s native language and make your program suitable for execution.

You will be able to see the output of your program, which should be Hello, world! .

The compilation of a C program consists of four steps: preprocessing, compilation, assembling, and linking.

The first step is preprocessing.

The preprocessor scans through the source code to find preprocessor directives, which are any lines that start with a # symbol, such as #include .

Once the preprocessor finds these lines, it substitutes them with something else.

For example, when the preprocessor finds the line #include <stdio.h> , the #include tells the preprocessor to include all the code from the stdio.h header file.

So, it replaces the #include <stdio.h> line with the actual contents of the stdio.h file.

The output of this phase is a modified version of the source code.

After preprocessing, the next step is the compilation phase, where the modified source code gets translated into the corresponding assembly code.

If there are any errors, compilation will fail, and you will need to fix the errors to continue.

The next step is the assembly phase, where the assembler converts the generated assembly code statements into machine code instructions.

The output of this phase is an object file, which contains the machine code instructions.

The last step is the linking phase.

Linking is the process of combining the object file generated from the assembly phase with any necessary libraries to create the final executable binary file.

Now, let’s go over the commands you need to enter to compile your main.c file.

In Visual Studio Code, open the built-in terminal by selecting "Terminal" -> "New Terminal".

Inside the terminal, enter the following command:

The gcc part of the command refers to the C compiler, and main.c is the file that contains the C code that you want to compile.

Next, enter the following command:

The ls command lists the contents of the current directory.

The output of this command shows an a.out file – this is the executable file containing the source code statements in their corresponding binary instructions.

The a.out is the default name of the executable file created during the compilation process.

To run this file, enter the following command:

This command tells the computer to look in the current directory, ./ , for a file named a.out .

The above command generates the following output:

You also have the option to name the executable file instead of leaving it with the default a.out name.

Say you wanted to name the executable file helloWorld .

If you wanted to do this, you would need to enter the following command:

This command with the -o option (which stands for output) tells the gcc compiler to create an executable file named helloWorld .

To run the new executable file that you just created, enter the following command:

This is the output of the above command:

Note that whenever you make a change to your source code file, you have to repeat the process of compiling and running your program from the beginning to see the changes you made.

Chapter 2: Variables and Data Types

In this chapter, you will learn the basics of variables and data types – the fundamental storage units that allow you to preserve and manipulate data in your programs.

By the end of this chapter, you will know how to declare and initialize variables.

You will also have learned about various data types available in C, such as integers, floating-point numbers, and characters, which dictate how information is processed and stored within a program's memory.

Finally, you'll have learned how to receive user input in your programs, and how to use constants to store values that you don't want to be changed.

What Is a Variable in C?

Variables store different kind of data in the computer's memory, and take up a certain amount of space.

By storing information in a variable, you can retrieve and manipule it, perform various calculations, or even use it to make decisions in your program.

The stored data is given a name, and that is how you are able to access it when you need it.

How to Declare Variables in C

Before you can use a variable, you need to declare it – this step lets the compiler know that it should allocate some memory for it.

C is a strongly typed language, so to declare a variable in C, you first need to specify the type of data the variable will hold, such as an integer to store a whole number, a floating-point number for numbers with decimal places, or a char for a single character.

That way, during compilation time, the compiler knows if the variable is able to perform the actions it was set out to do.

Once you have specified the data type, you give the variable a name.

The general syntax for declaring variables looks something like this:

Let's take the following example:

In the example above, I declared a variable named age that will hold integer values.

What Are the Naming Conventions for Variables in C?

When it comes to variable names, they must begin either with a letter or an underscore.

For example, age and _age are valid variable names.

Also, they can contain any uppercase or lowercase letters, numbers, or an underscore character. There can be no other special symbols besides an underscore.

Lastly, variable names are case-sensitive. For example, age is different from Age .

How to Initialize Variables in C

Once you've declared a variable, it is a good practice to intialize it, which involves assigning an initial value to the variable.

The general syntax for initialzing a variable looks like this:

The assignment operator, = , is used to assign the value to the variable_name .

Let's take the previous example and assign age a value:

I initialized the variable age by assigning it an integer value of 29 .

With that said, you can combine the initialization and declaration steps instead of performing them separately:

How to Update Variable Values in C

The values of variables can change.

For example, you can change the value of age without having to specify its type again.

Here is how you would change its value from 29 to 30 :

Note that the data type of the new value being assigned must match the declared data type of the variable.

If it doesn't, the program will not run as expected. The compiler will raise an error during compilation time.

What Are the Basic Data Types in C?

Data types specify the type of form that information can have in C programs. And they determine what kind of operations can be performed on that information.

There are various built-in data types in C such as char , int , and float .

Each of the data types requires different allocation of memory.

Before exploring each one in more detail, let’s first go over the difference between signed and unsigned data types in C.

Signed data types can represent both positive and negative values.

On the other hand, unsigned data types can represent only non-negative values (zero and positive values).

Wondering when to use signed and when to use unsigned data types?

Use signed data types when you need to represent both positive and negative values, such as when working with numbers that can have positive and negative variations.

And use unsigned data types when you want to ensure that a variable can only hold non-negative values, such as when dealing with quantities.

Now, let's look at C data types in more detail.

What Is the char Data Type in C?

The most basic data type in C is char .

It stands for "character" and it is one of the simplest and most fundamental data types in the C programming language.

You use it to store a single individual character such as an uppercase and lowercase letter of the ASCII (American Standard Code for Information Interchange) chart.

Some examples of char s are 'a' and 'Z' .

It can also store symbols such as '!' , and digits such as '7' .

Here is an example of how to create a variable that will hold a char value:

Notice how I used single quotation marks around the single character.

This is because you can't use double quotes when working with char s.

Double quotes are used for strings.

Regarding memory allocation, a signed char lets you store numbers ranging from [-128 to 127 ], and uses at least 1 byte (or 8 bits) of memory.

An unsigned char stores numbers ranging from [0 to 255] .

What Is the int Data Type in C?

An int is a an integer, which is also known as a whole number.

It can hold a positive or negative value or 0 , but it can't hold numbers that contain decimal points (like 3.5 ).

Some examples of integers are 0 , -3 ,and 9 .

Here is how you create a variable that will hold an int value:

When you declare an int , the computer allocates at least 2 bytes (or 16 bits) of memory.

With that said, on most modern systems, an int typically allocates 4 bytes (or 32 bits) of memory.

The range of available numbers for a signed int is [-32,768 to 32,767] when it takes up 2 bytes and [-2,147,483,648 to 2,147,483,647] when it takes up 4 bytes of memory.

The range of numbers for an unsigned int doesn't include any of the negative numbers in the range mentioned for signed int s.

So, the range of numbers for unsigned ints that take up 2 bytes of memory is [0 to 65,535] and the range is [0 to 4,294,967,295] for those that take up 4 bytes.

To represent smaller numbers, you can use another data type – the short int . It typically takes up 2 bytes (or 16 bits) of memory.

A signed short int allows for numbers in a range from [-32,768 to 32,767] .

An unsigned short int allows for numbers in a range from [0 to 65,535] .

Use a short when you want to work with smaller integers, or when memory optimisation is critically important.

If you need to work with larger integers, you can also use other data types like long int or long long int , which provide a larger range and higher precision.

A long int typically takes up at least 4 bytes of memory (or 32 bits).

The values for a signed long int range from [-2,147,483,648 to 2,147,483,647] .

And the values for an unsigned long int range from [0 to 4,294,967,295] .

The long long int data type is able to use even larger numbers than a long int . It usually takes up 8 bytes (or 64 bits) of memory.

A signed long long int allows for a range from [-9,223,372,036,854,775,808 to 9,223,372,036,854,775,807]

And an unsigned long long int has a range of numbers from [0 to 18,446,744,073,709,551,615] .

What Is The float Data Type in C?

The float data type is used to hold numbers with a decimal value (which are also known as real numbers).

It holds 4 bytes (or 32 bits) of memory and it is a single-precision floating-point type.

Here is how you create a variable that will hold a float value:

A double is a floating point value and is the most commonly used floating-point data type in C.

It holds 8 bytes (or 64 bits) of memory, and it is a double-precision floating-point type.

Here is how you create a variable that will hold a double value:

When choosing which floating-point data type to use, consider the trade-off between memory usage and precision.

A float has less precision that a double but consumes less memory.

Use a float when memory usage is a concern (such as when working with a system with limited resources) or when you need to perform calculations where high precision is not critical.

If you require higher precision and accuracy for your calculations and memory usage is not critical, you can use a double .

What Are Format Codes in C?

Format codes are used in input and output functions, such as scanf() and printf() , respectively.

They act as placeholders and substitutes for variables.

Specifically, they specify the expected format of input and output.

They tell the program how to format or interpret the data being passed to or read from the scanf() and printf() functions.

The syntax for format codes is the % character and the format specifier for the data type of the variable.

In the example above, age is the variable in the program. It is of type int .

The format code – or placeholder – for integer values is %i . This indicates that an integer should be printed.

In the program's output, %i is replaced with the value of age , which is 29 .

Here is a table with the format specifiers for each data type:

How to Recieve User Input Using the scanf() Function

Earlier you saw how to print something to the console using the printf() function.

But what happens when you want to receive user input? This is where the scanf() function comes in.

The scanf() function reads user input, which is typically entered via a keyboard.

The user enters a value, presses the Enter key, and the value is saved in a variable.

The general syntax for using scanf() looks something similar to the following:

Let's break it down:

• format_string is the string that lets the computer know what to expect. It specifies the expected format of the input. For example, is it a word, a number, or something else?
• &variable is the pointer to the variable where you want to store the value gathered from the user input.

Let's take a look at an example of scanf() in action:

In the example above, I first have to include the stdio.h header file, which provides input and output functions in C.

Then, in the main() function, I declare a variable named number that will hold integer values. This variable will store the user input.

Then, I prompt the user to enter a number using the printf() function.

Next, I use scanf() to read and save the value that the user enters.

The format specifier %i lets the computer known that it should expect an integer input.

Note also the & symbol before the variable name. Forgetting to add it will cause an error.

Lastly, after receiving the input, I display the received value to the console using another printf() function.

What are Constants in C?

As you saw earlier on, variable values can be changed throughout the life of a program.

With that said, there may be times when you don’t want a value to be changed. This is where constants come in handy.

In C, a constant is a variable with a value that cannot be changed after declaration and during the program's execution.

You can create a constant in a similar way to how you create variables.

The differences between constants and variables is that with constants you have to use the const keyword before mentioning the data type.

And when working with constants, you should always specify a value.

The general syntax for declaring constants in C looks like this:

Here, data_type represents the data type of the constant, constant_name is the name you choose for the constant, and value is the value of the constant.

It is also best practice to use all upper case letters when declaring a constant’s name.

Let’s see an example of how to create a constant in C:

In this example, LUCKY_NUM is defined as a constant with a value of 7 .

The constant's name, LUCKY_NUM , is in uppercase letters, as this is a best practice and convention that improves the readability of your code and distinguishes constants from variables.

Once defined, it cannot be modified in the program.

If you try to change its value, the C compiler will generate an error indicating that you are attempting to modify a constant.

Chapter 3: Operators

Operators are essential building blocks in all programming languages.

They let you perform various operations on variables and values using symbols.

And they let you compare variables and values against each other for decision-making computatons.

In this chapter, you will learn about the most common operators in C programming.

You will first learn about arithmetic operators, which allow you to perform basic mathematical calculations.

You will then learn about relational (also known as comparisson operators), which help you compare values.

And you will learn about logical operators, which allow you to make decisions based on conditions.

After understanding these fundamental operators, you'll learn about some additional operators, such as assignment operators, and increment and decrement operators.

By the end of this chapter, you will have a solid grasp of how to use different operators to manipulate data.

What Are the Arithmetic Operators in C?

Arithmetic operators are used to perform basic arithmetic operations on numeric data types.

Operations include addition, subtraction, multiplication, division, and calculating the remainder after division.

These are the main arithmetic operators in C:

Let's see examples of each one in action.

How to Use the Addition ( + ) Operator

The addition operator adds two operands together and returns their sum.

How to Use the Subtraction ( - ) Operator

The subtraction operator subtracts the second operand from the first operand and returns their difference.

How to Use the Multiplication ( * ) Operator

The multiplication operator multiplies two operands and returns their product.

How to Use the Division ( / ) Operator

The division operator divides the first operand by the second operand and returns their quotient.

How to Use the Modulo ( % ) Operator

The modulo operator returns the remainder of the first operand when divided by the second operand.

The modulo operator is commonly used to determine whether an integer is even or odd.

If the remainder of the operation is 1 , then the integer is odd. If there is no remainder, then the integer is even.

What Are The Relational Operators in C?

Relational operators are used to compare values and return a result.

The result is a Boolean value. A Boolean value is either true (represented by 1 ) or false (represented by 0 ).

These operators are commonly used in decision-making statements such as if statements, and while loops.

These are the relational operators in C:

Let’s see an example of each one in action.

How to Use the Equal to ( == ) Operator

The equal to operator checks if two values are equal.

It essentially asks the question, "Are these two values equal?"

Note that you use the comparisson operator (two equal signs – == ) and not the assignment operator ( = ) which is used for assigning a value to a variable.

The result is 1 (true), because a and b are equal.

How to Use the Not equal to ( != ) Operator

The not equal to operator checks if two values are NOT equal.

The result is 1 (true), because a and b are not equal.

How to Use the Greater than ( > ) Operator

This operator compares two values to check if one is greater than the other.

The result is 1 (true), because a is greater than b .

How to Use the Less than ( < ) Operator

This operator compares two values to check if one is less than the other.

The result is 0 (false), because a is not less than b .

How to Use the Greater than or Equal to ( >= ) Operator

This operator compares two values to check if one is greater than or equal to the other.

The result is 1 (true), because a is equal to b .

How to Use the Less than or equal to ( <= ) Operator

This operator compares two values to check if one is less than or equal the other.

The result is 1 (true), because a is less than b .

Logical Operators

Logical operators operate on Boolean values and return a Boolean value.

Here are the logical operators used in C:

Let's go into more detail on each one in the following sections.

How to Use the AND ( && ) Operator

The logical AND ( && ) operator checks whether all operands are true .

The result is true only when all operands are true .

Here is the truth table for the AND ( && ) operator when you are working with two operands:

The result of (10 == 10) && (20 == 20) is true because both operands are true .

Let's look at another example:

The result of (10 == 20) && (20 == 20) is false because one of the operands is false .

When the first operand is false , the second operand is not evaluated (since there's no point - it's already determined that the first operand is false, so the result can only be false ).

How to Use the OR ( || ) Operator

The logical OR ( || ) operator checks if at least one of the operands is true .

The result is true only when at least one of the operands is true .

Here is the truth table for the OR ( || ) operator when you are working with two operands:

Let's look at an example:

The result of (10 == 20) || (20 == 20) is true because one of the operands is true .

The result of (20 == 20) || (10 == 20) is true because one of the operands is true

If the first operand is true , then the second operator is not evaluated.

How to Use the NOT ( ! ) Operator

The logical NOT ( ! ) operator negates the operand.

If the operand is true , it returns false .

And if it is false , it returns true .

You may want to use the NOT operator when when you want to flip the value of a condition and return the opposite of what the condition evaluates to.

Here is the truth table for the NOT( ! ) operator:

The result of !(10 == 10) is false .

The condition 10 == 10 is true , but the ! operator negates it so the result is false .

And let's look at another example:

The result of !(10 == 20) is true .

The condition 10 == 20 is false, but the ! operator negates it.

What Is the Assignement Operator in C?

The assignment operator is used to assign a value to a variable.

In the example above, the value 10 is assigned to the variable num using the assignment operator.

The assignment operator works by evaluating the expression on the right-hand side and then storing its result in the variable on the left-hand side.

The type of data assigned should match the data type of the variable.

How to Use Compound Assignment Operators

Compound assignment operators are shorthand notations.

They allow you to modify a variable by performing an operation on it and then storing the result of the operation back into the same variable in a single step.

This can make your code more concise and easier to read.

Some common compound assignment operators in C include:

• += : Addition and assignment
• = : Subtraction and assignment
• = : Multiplication and assignment
• /= : Division and assignment
• %= : Modulo and assignment

Let’s see an example of how the += operator works:

In the example above, I created a variable named num and assigned it an initial value of 10 .

I then wanted to increment the variable by 5 . To do this, I used the += compound operator.

The line num += 5 increments the value of num by 5, and the result (15) is stored back into num in one step.

Note that the num += 5; line works exactly the same as doing num = num + 5 , which would mean num = 10 + 5 , but with fewer lines of code.

What Are the Increment and Decrement Operators in C?

The increment ++ and decrement -- operators increment and decrement a variable by one, respectively.

Let’s look at an example of how to use the ++ operator:

The initial value of the variable num is 10 .

By using the ++ increment operator, the value of num is set to 11 .

This is like perfoming num = num + 1 but with less code.

The shorthand for decrementing a variable by one is -- .

If you wanted to decrement num by one, you would do the following:

By using the -- increment operator, the value of num is now set to 9 . This is like perfoming num = num - 1 .

Chapter 4: Conditional Statements

The examples you have seen so far all execute line by line, from top to bottom.

They are not flexible and dynamic and do not adapt according to user behavior or specific situations.

In this chapter, you will learn how to make decisions and control the flow of a program.

You get to set the rules on what happens next in your programs by setting conditions using conditional statements.

Conditional statements take a specific action based on the result of a comparisson that takes place.

The program will decide what the next steps should be based on whether the conditions are met or not.

Certain parts of the program may not run depending on the results or depending on certain user input. The user can go down different paths depending on the various forks in the road that come up during a program's life.

First, you will learn about the if statement – the foundational building block of decision-making in C.

You will also learn about the else if and else statements that are added to the if statement to provide additional flexibility to the program.

You will then learn about the ternary operator which allows you to condense decision-making logic into a single line of code and improve the readability of your program.

How to Create an if statement in C

The most basic conditional statement in C is the if statement.

It makes a decision based on a condition.

If the given condition evaluates to true only then is the code inside the if block executed.

If the given condition evaluates to false , the code inside the if block is ignored and skipped.

The general syntax for an if statement in C is the following:

In the above code, I created a variable named age that holds an integer value.

I then prompted the user to enter their age and stored the answer in the variable age .

Then, I created a condition that checks whether the value contained in the variable age is less than 18.

If so, I want a message printed to the console letting the user know that to proceed, the user should be at least 18 years of age.

When asked for my age and I enter 16 , I'd get the following output:

The condition ( age < 18 ) evaluates to true so the code in the if block executes.

Then, I re-compile and re-run the program.

This time, when asked for my age, say I enter 28 , but I don't get any output:

This is because the condition evaluates to false and therefore the body of the if block is skipped.

I have also not specified what should happen in the case that the user's age is greater than 18.

To specify what happens in case the user's age is greater than 18, I can use an if else statement.

How to Create an if else statement in C

You can add an else clause to an if statement to provide code that will execute only when the if statement evaluates to false .

The if else statement essentially means that " if this condition is true do the following thing, else do this thing instead".

If the condition inside the parentheses evaluates to true , the code inside the if block will execute.

But if that condition evaluates to false , the code inside the else block will execute.

The else keyword is the solution for when the if condition is false and the code inside the if block doesn't run. It provides an alternative.

The general syntax looks like this:

Now, let's revisit the example from the previous section, and specify what should happen if the user's age is greater than 18:

If the condition is true the code in the if block runs:

If the condition is false the code in the if block is skipped and the code in the else block runs instead:

How to Create an else if statement in C

But what happens when you want to have more than one condition to choose from?

If you wish to chose between more than one option you can introduce an else if statement.

An else if statement essentially means that "If this condition is true, do the following. If it isn't, do this instead. However, if none of the above are true and all else fails, finally do this."

The general syntax looks something like the following:

Let's see how an else if statement works.

Say you have the following example:

If the first if statement is true, the rest of the block will not run:

If the first if statement is false, then the program moves on to the next condition.

If that is true the code inside the else if block executes and the rest of the block doesn't run:

If both of the previous conditions are all false, then the last resort is the else block which is the one to execute:

How to Use the Ternary Operator in C

The ternary operator (also known as the conditional operator) allows you to write an if else statement with fewer lines of code.

It can provide a way of writing more readable and concise code and comes in handy when writing simple conditional expressions.

You would want to use it when you are making making simple decisions and want to keep your code concise and on one line.

However, it's best to stick to a regular if-else statement when you are dealing with more complex decisions as the ternary operator could make your code hard to read.

The general syntax for the ternary operator looks something similar to the following:

• condition is the condition you want to evaluate. This condition will evaluate to either true of false
• ? separates the condition from the two possible expressions
• expression_if_true is executed if the condition evaluates to true
• : separates the expression_if_true from the expression_if_false
• expression_if_false is executed if the condition evaluates to false .

Let's take a look at an example:

In the example above, the condition is (x > 5) .

If x is greater than 5, the condition evaluates to true . And when the condition is true , the value assigned to y will be 100 .

If the condition evaluates to false , the value assigned to y will be 200 .

So, since x is greater than 5 ( x = 10 ), y is assigned the value 100 .

Chapter 5: Loops

In this chapter you will learn about loops, which are essential for automating repetitive tasks without having to write the same code multiple times.

Loops allow you to execute a specific block of code instructions repeatedly over and over again until a certain condition is met.

You will learn about the different types of loops, such as the for , while and do-while loops, and understand their syntax and when you should use each one.

You will also learn about the break statement, which allows you to control the execution flow within loops in specific ways.

How to Create a for Loop in C

A for loop allows you to execute a block of code repeatedly based on a specified condition.

It's useful when you know how many times you want to repeat a certain action.

The general syntax for a for loop looks like this:

• initialization is the step where you initialize a loop control variable. It's typically used to set the starting point for your loop.
• condition is the condition that is evaluated before each iteration. If the condition is true , the loop continues. If it's false , the loop terminates. The loop will run as long as the condition remains true.
• increment/decrement is the part responsible for changing the loop control variable after each iteration. It can be an increment ( ++ ), a decrement ( -- ), or any other modification.
• Code to be executed in each iteration is the block of code inside the for loop's body that gets executed in each iteration if the condition is true .

Let's see an example of how a for loop works.

Say you want to print the numbers from 1 to 5 to the console:

In the example above, I first initialize the loop control variable i with a value of 1 .

The condition i <= 5 is true, so the loop's body is executed and "Iteration 1" is printed.

After each iteration, the value of i is incremented by 1 . So, i is incremented to 2 .

The condition is still true , so "Iteration 2" is printed.

The loop will continue as long as i is less than or equal to 5 .

When i becomes 6 , the condition evaluates to false and the loop terminates.

How to Create a while Loop in C

As you saw in the previous section, a for loop is used when you know the exact number of iterations you want the loop to perform.

The while loop is useful when you want to repeat an action based on a condition but don't know the exact number of iterations beforehand.

Here is the general syntax of a while loop:

With a while loop, the condition is evaluated before each iteration. If the condition is true , the loop continues. If it's false, the loop terminates.

The while loop will continue as long as the condition evaluates to true .

Something to note with while loops is that the code in the loop's body is not guaranteed to run even at least one time if a condition is not met.

Let's see an example of how a while loop works:

In the example above, I first initialize a variable count with a value of 1 .

Before it runs any code, the while loop checks a condition.

The condition count <= 5 is true because count is initially 1 . So, the loop's body is executed and "Iteration 1" is printed.

Then, count is incremented to 2 .

The loop will continue as long as count is less than or equal to 5.

This process continues until count becomes 6 , at which point the condition becomes false , and the loop terminates.

Something to be aware of when working with while loops is accidentally creating an infinite loop:

In this case the condition always evaluates to true .

After printing the line of code inside the curly braces, it continuously checks wether it should run the code again.

As the answer is always yes (since the condition it needs to check is always true each and every time), it runs the code again and again and again.

The way to stop the program and escape from the endless loop is running Ctrl C in the terminal.

How to Create a do-while Loop in C

As mentioned in the previous section, the code in the while loop's body is not guaranteed to run even at least one time if the condition is not met.

A do-while loop executes a block of code repeatedly for as long as a condition remains true .

However, in contrast to a while loop, it is guaranteed to run at least once, regardless of whether the condition is true or false from the beginning.

So, the do-while loop is useful when you want to ensure that the loop's body is executed at least once before the condition is checked.

The general syntax for a do-while loop looks like this:

Let's take a look at an example that demonstrates how a do-while loop works:

In the example above I initialize a variable count with a value of 1 .

A do-while loop first does something and then checks a condition.

So, the block of code inside the loop is executed at least one time.

The string "Iteration 1" is printed and then count is incremented to 2 .

The condition count <= 5 is then checked and it evaluates to true , so the loop continues.

After the iteration where count is 6 , the condition becomes false , and the loop terminates.

How to Use the break Statement in C

The break statement is used to immediately exit a loop and terminate its execution.

It's a control flow statement that allows you to interrupt the normal loop execution and move on to the code after the loop.

The break statement is especially useful when you want to exit a loop under specific conditions, even if the loop's termination condition hasn't been met.

You might use it when you encounter a certain value, or when a specific condition is met.

Here's how to use a break statement in a loop:

In the example above, a for loop is set to iterate from 1 to 10 .

Inside the loop, the current value of i is printed on each iteration.

There is also an if statement that checks if the current value of i matches the target value, which is set to 5 .

If i matches the target value, the if statement is triggered and a message is printed.

As a result, the break statement exits the current loop immediately and prematurely.

The program will continue executing the code that is after the loop.

Chapter 6: Arrays

Arrays offer a versatile and organized way to store multiple pieces of related data that are arranged in an ordered sequence.

They allow you to store multiple values of the same data type under a single identifier and perform repetitive tasks on each element.

In this chapter, you will learn how to declare and initialize arrays. You will also learn how to access individual elements within an array using index notation and modify them.

In addition, you will learn how to use loops to iterate through array elements and perform operations on each element.

How to Declare and Initialize an Array in C

To declare an array in C, you first specify the data type of the elements the array will store.

This means you can create arrays of type int , float , char , and so on.

You then specify the array's name, followed by the array's size in square brackets.

The size of the array is the number of elements that it can hold. This number must be a positive integer.

Keep in mind that arrays have a fixed size, and once declared, you cannot change it later on.

Here is the general syntax for declaring an array:

Here is how to declare an array of integers:

In the example above, I created an array named grades that can store 5 int numbers.

After declaring an array, you can initialize it with initial values.

To do this, use the assignment operator, = , followed by curly braces, {} .

The curly braces will enclose the values, and each value needs to be separated by a comma.

Here is how to initialize the grades array:

Keep in mind that the number of values should match the array size, otherwise you will encounter errors.

Something to note here is that you can also partially initialize the array:

In this case, the remaining two elements will be set to 0 .

Another way to initialize arrays is to omit the array's length inside the square brackets and only assign the initial values, like so:

In this example, the array's size is 5 because I assigned it 5 values.

How to Find the Length of an Array in C Using the sizeof() Operator

The sizeof operator comes in handy when you need to calculate the size of an array.

Let's see an example of the sizeof operator in action:

In the example above, sizeof(grades) calculates the total size of the array in bytes.

In this case, the array has five integers.

As mentioned in a previous chapter, on most modern systems an int typically occupies 4 bytes of memory. Therefore, the total size is 5 x 4 = 20 bytes of memory for the entire array.

Here is how you can check how much memory each int occupies using the sizeof operator:

The sizeof(grades[0]) calculates the size of a single element in bytes.

By dividing the total size of the array by the size of a single element, you can calculate the number of elements in the array, which is equal to the array's length:

How to Access Array Elements in C

You can access each element in an array by specifying its index or its position in the array.

Note that in C, indexing starts at 0 instead of 1 .

So, the index of the first element is 0 , the index of the second element is 1 , and so on.

The last element in an array has an index of array_size - 1 .

To access individual elements in the array, you specify the array's name followed by the element's index number inside square brackets ( [] ).

Let's take a look at the following example:

In the example above, to access each item from the integer array grades , I have to specify the array's name along with the item's position in the array inside square brackets.

Remember that the index starts from 0 , so grades[0] gives you the first element, grades[1] gives you the second element, and so on.

Note that if you try to access an element with an index number that is higher than array_size - 1 , the compiler will return a random number:

How to Modify Array Elements in C

Once you know how to access array elements, you can then modify them.

The general syntax for modifying an array element looks like this:

You can change the value of an element by assigning a new value to it using its index.

Let's take the grades array from earlier on:

Here is how you would change the value 75 to 85 :

When modifying arrays, keep in mind that the new value must match the declared data type of the array.

How to Loop Through an Array in C

By looping through an array, you can access and perform operations on each element sequentially.

The for loop is commonly used to iterate through arrays.

When using a for loop to loop through an array, you have to specify the index as the loop variable, and then use the index to access each array element.

The %i placeholders are replaced with the current index i and the value at that index in the grades array, respectively.

You can also use a while loop to iterate through an array:

When using a while loop to loop through an array, you will need an index variable, int i = 0 , to keep track of the current position in the array.

The loop checks the condition (i < 5) and prints the index of the grade as well as the actual grade value.

After each grade is shown, the variable i is increased by one, and the loop continues until it has shown all the grades in the list.

A do-while works in a similar way to the while loop, but it is useful when you want to ensure that the loop body is executed at least once before checking the condition:

You can also use the sizeof operator to loop through an array.

This method is particularly useful to ensure your loop doesn't exceed the array's length:

The line int length = sizeof(grades) / sizeof(grades[0]); calculates the length of the grades array.

The length is calculated by dividing the total size (in bytes) of the array by the size of a single element grades[0] . The result is stored in the length variable.

The loop then iterates through the array using this length value.

For each iteration, it prints the index i and the value of the grade at that index grades[i] .

Chapter 7: Strings

In the previous chapter, you learned the basics of arrays in C.

Now, it's time to learn about strings – a special kind of array.

Strings are everywhere in programming. They are used to represent names, messages, passwords, and more.

In this chapter, you will learn about strings in C and how they are stored as arrays of characters.

You'll also learn the fundamentals of string manipulation.

Specifically, you will learn how to find a string's length and how to copy, concatenate, and compare strings in C.

What Are Strings in C?

A string is a sequence of characters, like letters, numbers, or symbols, that are used to represent text.

In C, strings are actually arrays of characters. And each character in the string has a specific position within the array.

Another unique characteristic of strings in C is that at the end of every one, there is a hidden \0 character called the 'null terminator'.

This terminator lets the computer know where the string ends.

So, the string ' Hello ' in C is stored as ' Hello\0 ' in memory.

How to Create Strings in C

One way to create a string in C is to initialize an array of characters.

The array will contain the characters that make up the string.

Here is how you would initialize an array to create the string 'Hello':

Note how I specified that the array should store 6 characters despite Hello being only 5 characters long. This is due to the null operator.

Make sure to include the null terminator, \0 , as the last character to signify the end of the string.

Let's look at how you would create the string 'Hello world':

In this example, there is a space between the word 'Hello' and the word 'world'.

So, the array must include a blank space character.

To print the string, you use the printf() function, the %s format code and the name of the array:

Another way to create a string in C is to use a string literal.

In this case, you create an array of characters and then assign the string by enclosing it in double quotes:

With string literals, the null terminator ( \0 ) is implied.

Creating strings with string literals is easier, as you don't need to add the null terminator at the end. This method is also much more readable and requires less code.

However, you may want to use character arrays when you want to modify the string's content. String literals are read-only, meaning the content is fixed.

How to Manipulate Strings in C

C provides functions that allow you to perform operations on strings, such as copying, concatenating, and comparing, to name a few.

To use these functions, you first need to include the string.h header file by adding the line #include <string.h> at the top of your file.

How to Find the Length of a String in C

To calculate the length of a string, use the strlen() function:

The strlen() function will return the number of characters that make up the string.

Note that the result does not include the null terminator, \0 .

How to Copy a String in C

To copy one string into another one, you can use the strcpy() function.

You may want to copy a string in C when you need to make changes to it without modifying it. It comes in handy when you need to keep the original string's content intact.

The general syntax for the strcpy() function looks like this:

The strcpy() function copies original_string into destination_string , including the null terminator ( '\0' ).

One thing to note here is that you need to make sure the destination array has enough space for the original string:

The strcpy() function copies the original string into an empty array and returns the copied string, which also includes the null terminator character ( '\0' ).

How to Concatenate Strings in C

You can concatenate (add) two strings together by using the strcat() function.

The general syntax for the strcat() function looks something like the following:

The strcat() function takes the original string and adds it to the end of destination string.

Make sure that the destination_string has enough memory for the original_string .

Something to note here is that strcat() does not create a new string.

Instead, it modifies the original destination_string , by including the original_string at the end.

Let's see an example of how strcat() works:

How to Compare Strings in C

To compare two strings for equality, you can use the strcmp() function.

The general syntax for the strcmp() function looks like this:

The strcmp() function compares string1 with string2 and returns an integer.

If the return value of strcmp() is 0 , then it means the two strings are the same:

If the return value of strcmp() is less than 0 , then it means the first word comes before the second:

And if the return value of strcmp() is greater than 0 , then it means the first word comes after the second one:

While this handbook has covered a wide range of topics, there is still so much to learn, as programming is so vast.

Once you have built a solid foundation with the basics of C programming, you may want to explore more advanced concepts.

You may want to move on to learning about functions, for example. They allow you to write instructions for a specific task and reuse that code throughout your program.

You may also want to learn about pointers. Pointers in C are like arrows that show you where a specific piece of information is stored in the computer's memory.

Then, you may want to move on to learning about structures. They're like custom data containers that allow you to group different types of information under one name.

Lastly, you may want to learn how to work with files. Working with files in C allows you to read from and write to files. This is useful for tasks like saving user data, reading configuration settings, or sharing data between different programs.

These suggestions are not a definitive guide – just a few ideas for you to continue your C programming learning journey.

If you are interested in learning more, you can check out the following freeCodeCamp resources:

• C Programming Tutorial for Beginners
• Learn C Programming Using the Classic Book by Kernighan and Ritchie
• Unlock the Mysteries of Pointers in C

This marks the end of this introduction to the C programming language.

Thank you so much for sticking with it and making it until the end.

You learned how to work with variables, various data types, and operators.

You also learned how to write conditional statements and loops. And you learned the basics of working with arrays and strings.

Hopefully, you have gained a good understanding of some of the fundamentals of C programming, got some inspiration on what to learn next, and are excited to continue your programming journey.

Happy coding!

Read more posts .

If this article was helpful, share it .

Learn to code for free. freeCodeCamp's open source curriculum has helped more than 40,000 people get jobs as developers. Get started

Next: Execution Control Expressions , Previous: Arithmetic , Up: Top   [ Contents ][ Index ]

7 Assignment Expressions

As a general concept in programming, an assignment is a construct that stores a new value into a place where values can be stored—for instance, in a variable. Such places are called lvalues (see Lvalues ) because they are locations that hold a value.

An assignment in C is an expression because it has a value; we call it an assignment expression . A simple assignment looks like

We say it assigns the value of the expression value-to-store to the location lvalue , or that it stores value-to-store there. You can think of the “l” in “lvalue” as standing for “left,” since that’s what you put on the left side of the assignment operator.

However, that’s not the only way to use an lvalue, and not all lvalues can be assigned to. To use the lvalue in the left side of an assignment, it has to be modifiable . In C, that means it was not declared with the type qualifier const (see const ).

The value of the assignment expression is that of lvalue after the new value is stored in it. This means you can use an assignment inside other expressions. Assignment operators are right-associative so that

is equivalent to

This is the only useful way for them to associate; the other way,

would be invalid since an assignment expression such as x = y is not valid as an lvalue.

Warning: Write parentheses around an assignment if you nest it inside another expression, unless that is a conditional expression, or comma-separated series, or another assignment.

cppreference.com

Assignment operators.

Assignment and compound assignment operators are binary operators that modify the variable to their left using the value to their right.

[ edit ] Simple assignment

The simple assignment operator expressions have the form

Assignment performs implicit conversion from the value of rhs to the type of lhs and then replaces the value in the object designated by lhs with the converted value of rhs .

Assignment also returns the same value as what was stored in lhs (so that expressions such as a = b = c are possible). The value category of the assignment operator is non-lvalue (so that expressions such as ( a = b ) = c are invalid).

rhs and lhs must satisfy one of the following:

• both lhs and rhs have compatible struct or union type, or..
• rhs must be implicitly convertible to lhs , which implies
• both lhs and rhs have arithmetic types , in which case lhs may be volatile -qualified or atomic (since C11)
• both lhs and rhs have pointer to compatible (ignoring qualifiers) types, or one of the pointers is a pointer to void, and the conversion would not add qualifiers to the pointed-to type. lhs may be volatile or restrict (since C99) -qualified or atomic (since C11) .
• lhs is a (possibly qualified or atomic (since C11) ) pointer and rhs is a null pointer constant such as NULL or a nullptr_t value (since C23)

[ edit ] Notes

If rhs and lhs overlap in memory (e.g. they are members of the same union), the behavior is undefined unless the overlap is exact and the types are compatible .

Although arrays are not assignable, an array wrapped in a struct is assignable to another object of the same (or compatible) struct type.

The side effect of updating lhs is sequenced after the value computations, but not the side effects of lhs and rhs themselves and the evaluations of the operands are, as usual, unsequenced relative to each other (so the expressions such as i = ++ i ; are undefined)

Assignment strips extra range and precision from floating-point expressions (see FLT_EVAL_METHOD ).

In C++, assignment operators are lvalue expressions, not so in C.

[ edit ] Compound assignment

The compound assignment operator expressions have the form

The expression lhs @= rhs is exactly the same as lhs = lhs @ ( rhs ) , except that lhs is evaluated only once.

[ edit ] References

• C17 standard (ISO/IEC 9899:2018):
• 6.5.16 Assignment operators (p: 72-73)
• C11 standard (ISO/IEC 9899:2011):
• 6.5.16 Assignment operators (p: 101-104)
• C99 standard (ISO/IEC 9899:1999):
• 6.5.16 Assignment operators (p: 91-93)
• C89/C90 standard (ISO/IEC 9899:1990):
• 3.3.16 Assignment operators

[ edit ] See Also

Operator precedence

[ edit ] See also

• Recent changes
• Offline version
• What links here
• Related changes
• Upload file
• Special pages
• Printable version
• Permanent link
• Page information
• In other languages
• This page was last modified on 19 August 2022, at 09:36.
• This page has been accessed 58,085 times.
• Privacy policy
• About cppreference.com
• Disclaimers

This browser is no longer supported.

Upgrade to Microsoft Edge to take advantage of the latest features, security updates, and technical support.

C Assignment Operators

• 6 contributors

An assignment operation assigns the value of the right-hand operand to the storage location named by the left-hand operand. Therefore, the left-hand operand of an assignment operation must be a modifiable l-value. After the assignment, an assignment expression has the value of the left operand but isn't an l-value.

assignment-expression :   conditional-expression   unary-expression assignment-operator assignment-expression

assignment-operator : one of   = *= /= %= += -= <<= >>= &= ^= |=

The assignment operators in C can both transform and assign values in a single operation. C provides the following assignment operators:

In assignment, the type of the right-hand value is converted to the type of the left-hand value, and the value is stored in the left operand after the assignment has taken place. The left operand must not be an array, a function, or a constant. The specific conversion path, which depends on the two types, is outlined in detail in Type Conversions .

• Assignment Operators

Was this page helpful?

Coming soon: Throughout 2024 we will be phasing out GitHub Issues as the feedback mechanism for content and replacing it with a new feedback system. For more information see: https://aka.ms/ContentUserFeedback .

Submit and view feedback for

Additional resources

Home » Learn C Programming from Scratch » C Assignment Operators

C Assignment Operators

Summary : in this tutorial, you’ll learn about the C assignment operators and how to use them effectively.

Introduction to the C assignment operators

An assignment operator assigns the vale of the right-hand operand to the left-hand operand. The following example uses the assignment operator (=) to assign 1 to the counter variable:

After the assignmment, the counter variable holds the number 1.

The following example adds 1 to the counter and assign the result to the counter:

The = assignment operator is called a simple assignment operator. It assigns the value of the left operand to the right operand.

Besides the simple assignment operator, C supports compound assignment operators. A compound assignment operator performs the operation specified by the additional operator and then assigns the result to the left operand.

The following example uses a compound-assignment operator (+=):

The expression:

is equivalent to the following expression:

The following table illustrates the compound-assignment operators in C:

• A simple assignment operator assigns the value of the left operand to the right operand.
• A compound assignment operator performs the operation specified by the additional operator and then assigns the result to the left operand.

Assignment and shorthand assignment operator in C

Quick links.

• Shorthand assignment

Assignment operator is used to assign value to a variable (memory location). There is a single assignment operator = in C. It evaluates expression on right side of = symbol and assigns evaluated value to left side the variable.

For example consider the below assignment table.

The RHS of assignment operator must be a constant, expression or variable. Whereas LHS must be a variable (valid memory location).

Shorthand assignment operator

C supports a short variant of assignment operator called compound assignment or shorthand assignment. Shorthand assignment operator combines one of the arithmetic or bitwise operators with assignment operator.

For example, consider following C statements.

The above expression a = a + 2 is equivalent to a += 2 .

Similarly, there are many shorthand assignment operators. Below is a list of shorthand assignment operators in C.

• Design Pattern
• Interview Q

C Control Statements

C functions, c dynamic memory, c structure union, c file handling, c preprocessor, c command line, c programming test, c interview.

• Send your Feedback to [email protected]

Help Others, Please Share

Learn Latest Tutorials

Transact-SQL

Reinforcement Learning

R Programming

React Native

Python Design Patterns

Python Pillow

Python Turtle

Preparation

Verbal Ability

Interview Questions

Company Questions

Trending Technologies

Artificial Intelligence

Cloud Computing

Data Science

Machine Learning

B.Tech / MCA

Data Structures

Operating System

Computer Network

Compiler Design

Computer Organization

Discrete Mathematics

Ethical Hacking

Computer Graphics

Software Engineering

Web Technology

Cyber Security

C Programming

Control System

Data Mining

Data Warehouse

• C - Introduction
• C - Comments
• C - Data Types
• C - Type Casting
• C - Operators
• C - Strings
• C - Booleans
• C - If Else
• C - While Loop
• C - For Loop
• C - goto Statement
• C - Continue Statement
• C - Break Statement
• C - Functions
• C - Scope of Variables
• C - Pointers
• C - Typedef
• C - Format Specifiers
• C Standard Library
• C - Data Structures
• C - Examples
• C - Interview Questions

• Programming Languages
• Web Technologies
• Database Technologies
• Microsoft Technologies
• Python Libraries
• Data Structures
• Interview Questions
• PHP & MySQL
• C++ Standard Library
• Java Utility Library
• Java Default Package
• PHP Function Reference

C - Bitwise OR and assignment operator

The Bitwise OR and assignment operator (|=) assigns the first operand a value equal to the result of Bitwise OR operation of two operands.

(x |= y) is equivalent to (x = x | y)

The Bitwise OR operator (|) is a binary operator which takes two bit patterns of equal length and performs the logical OR operation on each pair of corresponding bits. It returns 1 if either or both bits at the same position are 1, else returns 0.

The example below describes how bitwise OR operator works:

The code of using Bitwise OR operator (|) is given below:

The output of the above code will be:

Example: Find largest power of 2 less than or equal to given number

Consider an integer 1000. In the bit-wise format, it can be written as 1111101000. However, all bits are not written here. A complete representation will be 32 bit representation as given below:

Performing N |= (N>>i) operation, where i = 1, 2, 4, 8, 16 will change all right side bit to 1. When applied on 1000, the result in 32 bit representation is given below:

Adding one to this result and then right shifting the result by one place will give largest power of 2 less than or equal to 1000.

The below code will calculate the largest power of 2 less than or equal to given number.

The above code will give the following output:

• Data Structures Tutorial
• Algorithms Tutorial
• JavaScript Tutorial
• Python Tutorial
• MySQLi Tutorial
• Java Tutorial
• Scala Tutorial
• C++ Tutorial
• C# Tutorial
• PHP Tutorial
• MySQL Tutorial
• SQL Tutorial
• PHP Function reference
• C++ - Standard Library
• Java.lang Package
• Ruby Tutorial
• Rust Tutorial
• Swift Tutorial
• Perl Tutorial
• HTML Tutorial
• CSS Tutorial
• AJAX Tutorial
• XML Tutorial
• Online Compilers
• QuickTables
• NumPy Tutorial
• Pandas Tutorial
• Matplotlib Tutorial
• SciPy Tutorial
• Seaborn Tutorial

Assignment Statement in C

How to assign values to the variables? C provides an  assignment operator  for this purpose, assigning the value to a variable using assignment operator is known as an assignment statement in C.

The function of this operator is to assign the values or values in variables on right hand side of an expression to variables on the left hand side.

The syntax of the  assignment expression

Variable = constant / variable/ expression;

The data type of the variable on left hand side should match the data type of constant/variable/expression on right hand side with a few exceptions where automatic type conversions are possible.

Examples of assignment statements,

b = c ; /* b is assigned the value of c */ a = 9 ; /* a is assigned the value 9*/ b = c+5; /* b is assigned the value of expr c+5 */

The expression on the right hand side of the assignment statement can be:

An arithmetic expression; A relational expression; A logical expression; A mixed expression.

The above mentioned expressions are different in terms of the type of operators connecting the variables and constants on the right hand side of the variable. Arithmetic operators, relational

Arithmetic operators, relational operators and logical operators are discussed in the following sections.

For example, int a; float b,c ,avg, t; avg = (b+c) / 2; /*arithmetic expression */ a = b && c; /*logical expression*/ a = (b+c) && (b<c); /* mixed expression*/

Share this:

• Click to share on Twitter (Opens in new window)
• Click to share on Facebook (Opens in new window)

Related Posts

• #define to implement constants
• Preprocessor in C Language
• Pointers and Strings

Leave a Reply Cancel reply

Your email address will not be published. Required fields are marked *

Save my name, email, and website in this browser for the next time I comment.

Notify me of follow-up comments by email.

Notify me of new posts by email.

This site uses Akismet to reduce spam. Learn how your comment data is processed .

Browse Course Material

Course info, instructors.

• Daniel Weller
• Sharat Chikkerur

Departments

• Electrical Engineering and Computer Science

As Taught In

• Programming Languages
• Software Design and Engineering

Learning Resource Types

Practical programming in c, assignments.

You are leaving MIT OpenCourseWare

Navigation Menu

Search code, repositories, users, issues, pull requests..., provide feedback.

We read every piece of feedback, and take your input very seriously.

Saved searches

Use saved searches to filter your results more quickly.

To see all available qualifiers, see our documentation .

• Notifications You must be signed in to change notification settings

An assignment of primary programming in THU, 2024 spring. It requires you to make your own maze as a game(open it by cmd) by C.

ShirakawaSanae/THUPrimaryProgramming-C-2024Spring

Folders and files, repository files navigation, this assignment requires you to make a maze by c..

You have to complete the following requierments:

• create a map of maze randomly, by typing in WIDTH and HEIGHT . (NOT larger than 50*50)
• ensure that there exists at least one path from Start to End.
• player can move by ‘w''a''s''d', quit by 'q'.
• support automatically way-finding. (help the player!)
• when player won the game, ask whether he/she wants another game. (press [y/n])

You can also add other user-friendly function like timer, dialog, BGM, warning of Invalid Input, etc.

Advanced C Programming

Summer 2024 ece 26400 :: purdue university, editing: vim.

This assignment has the following goals.

• Learn to use the Vim text editor to efficiently move around a code file and make changes.
• Practice improving the style of poorly formatted code.
• Get to know how grades will be calculated in this course.

In this course, you will work on the ecegrid server. That's where you will get your starter files (if any), pre-test your submission (when possible), and submit your code. This gives everyone the same environment, with the same version of the tools (e.g., gcc, vim, etc.), and the same platform for testing code.

Before you proceed, please complete the setup .

Start learning Vim

This assignment is your chance to get good at editing code in Vim, before we get to the more challenging C programming assignments. You should take this opportunity to learn it well.

Bare minimum: Go through vimtutor

vimtutor is an interactive tutorial that is installed on ecegrid and every computer where Vim is installed. At the command line, just enter vimtutor and follow the instructions.

This will take about 15-30 minutes, and will make the rest of this much easier. The Resources page has some web-based options, which look nicer but are less complete.

Recommended: Print out a reference sheet (or two or three)

Recommended: watch a video (or two or three), get the homework files.

To fetch the files for this assignment, enter 264get hw01 from bash. That should create a new directory called hw01. To see the directory enter ls . Next, enter cd hw01 to enter the directory and start working.

Do the homework

Here's the scenario: You have been given a partially-working calculator for ECE 264 grades. However, the code is very messy. First, you will fix the formatting. Next, you will complete the code. Finally, you will finish the code so that it prints out a course grade.

For this assignment, we will record the keys you type into vim. When the assignment is scored, we will play the keys back to verify if you reached the intended result. You will start with before.c and finish with goal.c . Do not modify goal.c or before.c . You may need those.

Do not use the arrow keys or mouse. As with any tool, your coding will be most efficient if you use Vim in the way that it was designed (e.g., j for down, k for up, etc.). For this assignment, you are required to work in this way.

We will give you hints in purple for some steps. For the others, you will need to use what you learned from vimtutor and/or the reference sheet. In this explanation, <esc> refers to the Escape key, <enter> refers to the Enter key, <tab> refers to the Tab key, and <space> refers to the spacebar.

One session. You must do the entire process in one vim session.

Repetition. If you exit vim before the files match, you will need to start over. For that reason, you may end up doing the whole process several times. The repitition will serve as good practice. Once you are very comfortable with vim and understand what you are doing, it shouldn't take more than about 10 minutes to edit before.c into goal.c.

Do not use the arrow keys or mouse. You will not receive credit if you do. To avoid accidentally using them, enter the following command in vim (from normal mode): :DisableMouseAndArrowKeys and press enter. Do not depend on that command completely as it might not catch all arrow keys.

Spacing. Pay close attention to the spacing in goal.c. For example, all of the // hw# and // exam# comments start in column 11. The comma in those lines is in column 8. Vim shows the current line and column in the lower-right corner of your screen.

Splits. Opening a split while editing your after.c and recording your recorded.vim will probably work out okay, but it isn't recommended. We suspect it might lead to inconsistencies when the keystrokes are played back, but we haven't verified this. If your recorded.vim is passing the HW01 pretester (264test_special_vim), then you should get 100% credit.

-W not -w . When typing vim -W recorded.vim -n -i NONE after.c , the -W must be uppercase (i.e., -W not -w ).

-W only for recording. If you want to look at the files after you are done, be sure to not use the -W recorded.vim argument to vim. Otherwise, you will overwrite your recorded.vim and you will have to start over.

File size. Your recorded.vim will be likely be >1500 bytes, and probably much more. If it is very small (e.g., 0 bytes), you probably overwrote it. (Type ls -l from bash to see the file sizes.)

From bash, enter cp before.c after.c to make a copy of the pristine starter file.

Next, enter vim -W recorded.vim -n -i NONE after.c to open it in vim.

The extra parameters ( -W recorded.vim -n -i NONE ) are only for this assignment. For those who are curious… The -W recorded.vim parameter makes it record your keystrokes. The -i NONE parameter tells Vim to start fresh (i.e., forget macros and marks leftover from previous sessions). That way, when we replay your session, we will get the same result you got. The -n parameter turns off the swap file.

• Fix the missing semicolon on line 4.
• Move to line 4. 4G
• Append a semicolon at the end. A;<esc>
• Indent the body (everything inside the curly braces) of the average function, which starts on line 12 15 .
• Search for " average ".    /average<enter>
• Go down one line (to get to the beginning of the body of this function). j
• Select the current line using visual mode. V
• Extend the selection to include the rest of the body of this function. jjjj
• Indent everything that is selected. >
• Indent the body of the for loop inside the average function.
• Move to line 19 16 .
• Indent the current line. >>
• Indent the bodies of the weighted_sum , weighted_average , and main functions, as well as any for loops inside them.
• Add a blank line after the second #include statement at the top.
• Jump to the beginning of the file. gg
• Move your cursor to beginning of the second #include statement. jj
• Start a blank line below the current line. o (lowercase letter)
• Exit insert mode (to get back to normal mode) <esc>
• Add a blank line between the declarations of HOMEWORK_WEIGHTS and NUM_EXAMS .
• Add a blank line above the declaration of the average function.
• Search for "average".
• Enter a blank line above the current line. O (uppercase letter)
• Exit insert mode (to get back to normal mode).
• Ensure that there is exactly one blank line above all function declarations.
• In the const arrays declared at the top of the file ( HOMEWORK_SCORES , HOMEWORK_WEIGHTS , EXAM_SCORES , EXAM_WEIGHTS ), put each number on its own line.
• Jump to the top of the file.
• Move down to line 6 5 .
• Move to the beginning of the line. 0 (zero)
• Move right by 4 words. wwww
• Insert a carriage return, and then immediately exit insert mode (back to normal mode) i<enter><esc>
• Start creating a quick macro so you don't have to do that so many times. qq
• Move right by words until the cursor is at the beginning of a number. www
• Insert a carriage return and then immediately exit insert mode (back to normal mode).
• Stop recording the quick macro. q
• Replay the macro once. @q
• Replay the same macro several more times. @@@@@@@@@@@@ (…and so on)
• Insert a carriage return just before the ending curly brace ( } ) and ensure that it is flush with the left side (i.e., not indented).
• Follow a similar procedure for HOMEWORK_WEIGHTS , EXAM_SCORES , and EXAM_WEIGHTS .
• Right align all of the numbers.
• Move to the first 2-digit number in HOMEWORK_SCORES (70).
• Insert one space before the line beginning. I<space>
• Go down one line (to get to the number 80).
• Repeat the last action. (period)
• Do likewise for the rest of the two-digit numbers in HOMEWORK_SCORES .
• Add a comment after every number in each of the const arrays declared at the top of the file ( HOMEWORK_SCORES , HOMEWORK_WEIGHTS , EXAM_SCORES , EXAM_WEIGHTS ), to indicate which homework or exam they refer to.
• Move to the first number in HOMEWORK_SCORES .
• Append the text " // hw " at the end of the line. A<space><space>//<space>hw<esc>
• Move back to the first number in HOMEWORK_SCORES .
• Append the number "1" at the end of the line so that the comment reads " // hw1 ".
• Append the numbers "2" to "15" at the end of the remaining lines in HOMEWORK_SCORES .
• Ensure that there is exactly one space after every comma in a function parameter list.
• Ensure that there is exactly one space before and after every arithmetic operator, as shown in goal.c.
• For the very long arithmetic expressions ( exam_score , and summary_score ), break them into two lines but align the equals sign in the first line with the plus sign in the second line, as shown in goal.c.
• There is a bug. The print_grade(…) function is used in main(…) but is never defined. Add the following function just above main(…) : void print_grade(float summary_score) { printf("summary score: %.2f\n", summary_score); }
• Save. :w<enter>
• Modify the print_grade(…) function so that instead of printing the summary score, it prints the letter grade. You will need an if statement (or if else) for each possible letter grade. Do not type all of these repeatedly . Instead, you will use copy-paste. (In vim parlance, these are called yank and put.)
• Move to the definition of the print_grade(…) function.
• Move to the end of the line. $
• Move to the corresponding closing curly brace. %
• Move up one line.
• Delete the current line ( "printf(…" ). You should now be back on the closing curly brace.
• Add a line above this closing curly brace. This is where you will enter the code to print the letter grade.
• Type the following code. if(summary_score >= 85) { printf("A\n"); }
• Select the ending curly brace using visual mode.
• Extend the selection upward to include all 3 lines of this if statement and its body.
• Yank (copy) the selection. y
• Move back to the ending curly brace of the if statement.
• Put (paste) the text that you previously yanked directly below the if statement. p
• Insert the text " else " at the beginning of this line.
• Change "85" to "82" and change "A" to "A-" so that you have the following: if(summary_score >= 85) { printf("A\n"); } else if(summary_score >= 82) { printf("A-\n"); }
• Add three copies of the else if clause and adjust the score and grade letter so that you have the following: if(summary_score >= 85) { printf("A\n"); } else if(summary_score >= 82) { printf("A-\n"); } else if(summary_score >= 78) { printf("B+\n"); } else if(summary_score >= 75) { printf("B\n"); } else if(summary_score >= 72) { printf("B-\n"); }
• Using a similar method, copy these 9 lines to insert the code for "C+", "C", and "C-". Repeat for "D+", "D", "D-".
• Add the else clause for the “F” grade.
• Fix the two for loops so that they conform to the Code Quality Standards , especially with respect to curly braces and for loop counter scope
• Make any other changes needed so that your after.c file is identical to goal.c.
• Exit vim. :q<enter>

There is a special pretester for HW01. From your hw01 directory, type 264test_special_vim . That will replay your keystrokes (recorded.vim) in vim and display any differences with goal.c. If there are no differences, then you are done. Your task is to edit before.c after.c to make it identical to goal.c. If it prints a "Congratulations..." message, you should receive 100%, once scores are posted (probably next week).

HW01 is special in that it is the only homework that offers a pretester with a guarantee. On all future assignments, you will be solely responsible for testing your code. If a pretester is offered, it may be only a partial check, and it may not be available all the time.

This is from a previous semester. This way of testing works most of the time, but has a pitfall. We are leaving this in here for now, in case it might be useful.

There are two ways to test your recorded.vim to make sure you got this right. The best—in terms of your learning—is to use the diff command as follows: cp before.c after.c vim -s recorded.vim after.c diff after.c goal.c

If it prints nothing, then it means after.c and goal.c are identical so you did the assignment perfectly. Otherwise, if it prints any lines, then those lines must have some differences, so you will need to repeat the process. Note that this method of testing will not work properly if you have used the undo command ( u ) within vim. In that case, try the next method.

Submit (or save)

In general, to submit any assignment for this course, you will use the following command:

For HW01, you will type 264submit hw01 recorded.vim from inside your hw01 directory.

You can submit as often as you want, even if you are not finished with the assignment. That saves a backup copy which we can retrieve for you if you ever have a problem.

Before you consider this done, you may want to look over the section on pitfalls above.

How much work is this?

For those who do not know vim (or don't know it very well), we estimate it may take about 2 hours to go through the tutorial(s) and another 2 hours to edit the before.c to make it identical to goal.c, including time for several repetitions.

If you already know vim well, this assignment should be very easy.

How do I know if I have used any arrow keys?

The pretester (264test_special_vim) will tell you.

• <80> ku
• <80> kd
• <80> kl
• <80> kr

I made a tiny mistake. How can I fix it?

Is it best to start over. The practice will help you get more comfortable editing code with Vim.

I accidentally pressed arrow keys. What should I do?

Start over.

How do I start over?

Make a fresh copy of before.c like this:

Then open Vim using the special flags for HW01:

Isn't there an easier way than starting over?

There are some hacky ways to recover if you made a small mistake, but they are not supported because they won't save much time (if any) and they won't teach you anything useful.

Repeating the process in this assignment will give you additional practice and help you develop muscle memory for the commands.

What if I accidentally click the mouse in the window?

If i quit and come back, can i start where i left off.

Short answer: No.

You should do the whole process in one session.

If you quit, it will leave a :q (or similar) command in your recorded.vim file. We looked into possibly filtering those out, but it gets complicated to do properly. Editing your recorded.vim file to remove the :q<enter> is a possibility. You might try doing :vert diffsplit goal.c to see differences and fix them. (You would open your after.c and then enter that command from inside Vim.)

How can I see what my recorded.vim contains?

Run this utility. you@eceprog ~/264/hw01 $ vim_pretty_print recorded.vim

Note: vim_pretty_print is not a standard utility. Prof. Burnett made it to help with this assignment.

May I edit my recorded.vim file directly?

It is not recommended and not supported.

Editing code proficiently in Vim is a skill that will be an asset to you as a programmer in the future. Fiddling with the recorded.vim will be useful to nobody, beyond this assignment.

The script you turn in must be able to transform before.c into goal.c . If you can find a way to edit your script to make that work, that's fine. However, it may be easiest to just start over. Once you've learned the commands that this assignment uses, the process of transforming before.c into goal.c should be relatively quick.

How will this be scored?

How can i be sure i will get 100%, what if i get the “ congratulations ” (in green) but i do not receive 100% credit.

It is unlikely that our tester would give a different result from the pretester you were given (264test_special_vim), but if it happens, we will honor the result from the pretester. (Note: This is the only pretester that offers such a guarantee.)

What if I get it close, but it does not print “ Congratulations ” (in green)?

What is vim, what's the difference between vim and vi, where can i use it, can i use the mouse with vim, can i use tabs, can i get syntax highlighting, purpose of this assignment, i already know an editor. why should i learn vim.

Even if you know and love some other editor, learning Vim will make you a more versatile programmer. Unlike most other editors, Vim can be used through a terminal (e.g., PuTTY, ssh), which will make your life a lot easier for all homework assignments in this course. this course

In ECE 264, you will find the workflow for homework assignments a lot simpler and less error-prone if you work directly on ecegrid through an SSH terminal. The course is optimized for working in this way. You will fetch starter files, test your code, and submit—all through an SSH window. Although it would be possible to write your code in another editor on your computer (e.g., Sublime, TextMate, etc.), and transfer the files to ecegrid, that would be inefficient and error-prone. Once you are comfortable editing code through an SSH terminal, you will not need to transfer any files anywhere. Out in the world, that comes in handy when editing code that runs on a server, as well as some embedded systems.

Why not Emacs?

Emacs is the only other viable choice for coding in a terminal. Like Vim, it is a very powerful tool for programmers who take the time to learn it well.

We chose Vim for this course because (a) it is introduced lightly in CS 159, (b) its key replay features makes this assignment possible, and (c) it is available and usually pre-installed on practically every Linux/UNIX-based system in the world.

For decades, there was an ongoing debate over which of the two was better. (Search for [ editor war ] or [ vim vs. emacs ], or just read this great article on Slate .) In recent years, several online polls ( here , here , and here ) have found Vim to be more “popular”, by a ratio of around 4 to 1. However, both have unique features and virtues that appeal to different people. Those who prefer Emacs have plenty of great reasons to do so. The choice of Vim for this class was borne of pragmatism.

Why are we learning any editor? Why not just focus on C?

Do i always have to use vim, are there any drawbacks to using some other editor.

Yes. If you use a local editor (i.e., running on your laptop or desktop computer), you will need to transfer the starter files from ecegrid to your computer. Then, every time you want to test them, you will need to transfer your code back to ecegrid. Your code must compile and run on ecegrid using our version of the gcc, so it is important to test on ecegrid. Finally, when you are ready to submit, you will again need to transfer your files.

If you already know Emacs well , there is no drawback to using that for future assignments. Emacs is installed on ecegrid, and works well through an SSH terminal.

How can I possibly learn to use Vim while simultaneously solving challenging programming assignments?

What do the codes mean that i see in recorded.vim.

Learn C practically and Get Certified .

Popular Tutorials

Popular examples, reference materials, learn c interactively, c introduction.

• Getting Started with C
• Your First C Program

C Fundamentals

• C Variables, Constants and Literals
• C Data Types
• C Input Output (I/O)
• C Programming Operators

C Flow Control

• C if...else Statement
• C while and do...while Loop
• C break and continue
• C switch Statement
• C goto Statement
• C Functions
• C User-defined functions
• Types of User-defined Functions in C Programming
• C Recursion
• C Storage Class

C Programming Arrays

C Multidimensional Arrays

Pass arrays to a function in C

C Programming Pointers

Relationship Between Arrays and Pointers

• C Pass Addresses and Pointers
• C Dynamic Memory Allocation
• C Array and Pointer Examples
• C Programming Strings
• String Manipulations In C Programming Using Library Functions
• String Examples in C Programming

C Structure and Union

• C structs and Pointers
• C Structure and Function

C Programming Files

• C File Handling

C Files Examples

C Additional Topics

• C Keywords and Identifiers
• C Precedence And Associativity Of Operators
• C Bitwise Operators
• C Preprocessor and Macros
• C Standard Library Functions

C Tutorials

• Find Largest Element in an Array
• Calculate Average Using Arrays
• Access Array Elements Using Pointer
• Add Two Matrices Using Multi-dimensional Arrays

An array is a variable that can store multiple values. For example, if you want to store 100 integers, you can create an array for it.

How to declare an array?

For example,

Here, we declared an array, mark , of floating-point type. And its size is 5. Meaning, it can hold 5 floating-point values.

It's important to note that the size and type of an array cannot be changed once it is declared.

Access Array Elements

You can access elements of an array by indices.

Suppose you declared an array mark as above. The first element is mark[0] , the second element is mark[1] and so on.

Few keynotes :

• Arrays have 0 as the first index, not 1. In this example, mark[0] is the first element.
• If the size of an array is n , to access the last element, the n-1 index is used. In this example, mark[4]
• Suppose the starting address of mark[0] is 2120d . Then, the address of the mark[1] will be 2124d . Similarly, the address of mark[2] will be 2128d and so on. This is because the size of a float is 4 bytes.

How to initialize an array?

It is possible to initialize an array during declaration. For example,

You can also initialize an array like this.

Here, we haven't specified the size. However, the compiler knows its size is 5 as we are initializing it with 5 elements.

Change Value of Array elements

Input and output array elements.

Here's how you can take input from the user and store it in an array element.

Here's how you can print an individual element of an array.

Example 1: Array Input/Output

Here, we have used a  for loop to take 5 inputs from the user and store them in an array. Then, using another  for loop, these elements are displayed on the screen.

Example 2: Calculate Average

Here, we have computed the average of n numbers entered by the user.

Access elements out of its bound!

Suppose you declared an array of 10 elements. Let's say,

You can access the array elements from testArray[0] to testArray[9] .

Now let's say if you try to access testArray[12] . The element is not available. This may cause unexpected output (undefined behavior). Sometimes you might get an error and some other time your program may run correctly.

Hence, you should never access elements of an array outside of its bound.

Multidimensional arrays

In this tutorial, you learned about arrays. These arrays are called one-dimensional arrays.

In the next tutorial, you will learn about multidimensional arrays (array of an array) .

Table of Contents

• C Arrays (Introduction)
• Declaring an Array
• Access array elements
• Initializing an array
• Change Value of Array Elements
• Array Input/Output
• Example: Calculate Average
• Array Elements Out of its Bound

Video: C Arrays

Sorry about that.

Related Tutorials

• Trending Now
• Foundational Courses
• Data Science
• Practice Problem
• Machine Learning
• System Design
• DevOps Tutorial
• What is Task Assignment Approach in Distributed System?
• Process Addressing in Distributed System
• Why do we need a distributed system?
• Design Principles of Distributed File System
• How can Heartbeats Detection provide a solution to network failures in Distributed Systems
• Distributed Messaging System | System Design
• Consistency Model in Distributed System
• Scheduling and Load Balancing in Distributed System
• Hashing in Distributed Systems
• Agreement Protocol in Distributed Systems
• What is a Distributed Operating System?
• Durability in Distributive Systems | Learn System Design
• Design Principles of Security in Distributed System
• Hierarchical Deadlock Detection in Distributed System
• Exception Handling in Distributed System
• Design Distributed Job Scheduler | System Design
• Design Issues of Distributed System
• Project Idea | Distributed Downloading System
• How to add unique Id to each record in your local/custom database in Node.js ?

How to Assign a Node ID to Each Node in Distributed Systems?

Assigning Node IDs in distributed systems is very important for managing and identifying nodes. Node IDs ensure efficient communication and data management within the system. Each node must have a unique identifier to prevent confusion. Proper ID assignment enhances system reliability and performance. In this article, we are going to explore methods to assign Node IDs and their benefits.

Important Topics to Understand How to Assign a Node ID to Each Node in Distributed Systems?

Node Identification in Distributed Systems

Types of node ids in distributed systems, generating node ids in distributed systems, assignment strategies for node ids in distributed systems, node id collision handling in distributed systems, integration with distributed system architecture, examples of node id assignment in distributed systems, challenges and best practices for assigning node id to each node in distributed systems.

• Node identification is the process of assigning a unique identifier to each node within a distributed system.
• This identifier ensures that each node can be distinctly recognized, facilitating accurate communication, data management, and coordination among all nodes in the network.
• Each node must be uniquely identifiable to ensure proper communication and data handling.
• Without unique identifiers, it becomes difficult to manage tasks, route messages, and maintain system integrity. Node identification ensures that each part of the system can function cohesively.
• In distributed systems, nodes can be servers, computers, sensors, or any devices participating in the network. Each node performs specific tasks and communicates with others to complete complex operations.
• Unique Node IDs prevent conflicts and ensure that messages are delivered to the correct destination. This is vital for maintaining the system’s overall efficiency and reliability.
• Effective node identification also enhances fault tolerance and scalability . When a system can accurately identify each node, it can better manage node failures and redistribute tasks. This identification helps in adding new nodes to the system without disrupting existing operations.

Different types of Node IDs offer various advantages depending on the specific needs and architecture of the system. Here are the main types of Node IDs used in distributed systems.

• Numeric IDs are simple numbers assigned to each node.
• They are easy to generate and manage.
• Numeric IDs are typically sequential, making it straightforward to add new nodes. However, this simplicity may lead to collisions if not managed properly.
• UUIDs are 128-bit identifiers designed to be globally unique.
• They are complex strings that provide a high degree of uniqueness.
• UUIDs ensure that no two nodes have the same ID, even in different systems.
• They are ideal for systems requiring absolute uniqueness but are more complex to generate and manage.
• Hierarchical IDs reflect the node’s position within a network hierarchy.
• These IDs often include segments representing different levels of the hierarchy.
• They are useful for structured systems, where the position of each node is important.
• Hierarchical IDs simplify the organization and management of nodes in large systems.
• Hash-based IDs are generated using hash functions, which convert data inputs into a fixed-size string of characters.
• This method ensures a wide distribution of IDs, reducing the likelihood of collisions.
• Hash-based IDs are efficient and can be generated quickly, making them suitable for dynamic and large-scale systems.
• IP-based IDs use the IP addresses of nodes as their identifiers.
• This method is straightforward and leverages existing network infrastructure. I
• P-based IDs are useful for systems where nodes have fixed IP addresses.
• However, they can be less effective in environments with dynamic IP allocation.
• MAC-based IDs use the MAC addresses of network interface cards.
• They provide a unique identifier for each node based on its hardware address.
• MAC-based IDs are reliable and unique, making them useful in networked systems. However, they are hardware-dependent and may not be suitable for all types of distributed systems.

Generating Node IDs is a critical process in distributed systems. It ensures that each node receives a unique identifier, facilitating efficient communication and management. Various methods can be used to generate these IDs, each with its own advantages and use cases. Choosing the right method depends on the system’s requirements for uniqueness, scalability, and efficiency.

Below are some common methods for generating Node IDs.

• In this method, a central authority is responsible for assigning Node IDs.
• This approach is simple and ensures uniqueness.
• However, it can become a bottleneck and single point of failure.
• Example: In a small distributed system, a central server assigns IDs sequentially. When a new node joins, it requests an ID from the server. The server assigns ID 001, then 002 for the next node, and so on.
• Nodes generate their own IDs without a central authority. This requires mechanisms to detect and resolve collisions, ensuring uniqueness.
• Example: Each node uses a random number generator to create its ID. If two nodes generate the same ID, they detect the collision and regenerate a new one.
• Combines centralized and decentralized methods to balance efficiency and scalability.
• A central authority might provide initial guidelines, but nodes generate their own IDs within those parameters.
• Example: A central server provides a range of IDs to each node. Nodes then generate IDs within this range, reducing the load on the central server and distributing the task.
• Universally Unique Identifiers (UUIDs) are 128-bit values that ensure global uniqueness. They can be generated using algorithms that consider factors like the current time and node-specific information.
• Example: A node generates a UUID like “550e8400-e29b-41d4-a716-446655440000”. This ID is unique across all nodes and systems, eliminating the risk of collision.
• Nodes generate IDs using hash functions. This method ensures a wide distribution of IDs and reduces collision likelihood.
• Example: A node uses a hash function on its IP address to generate an ID. If the IP is “192.168.1.1”, the hash function might produce “e4d909c290d0fb1ca068ffaddf22cbd0”.
• This method uses the node’s IP address as its ID.
• This method is straightforward and uses existing network infrastructure.
• Example: A node with IP address “192.168.1.1” uses “19216811” as its ID. This ensures uniqueness as long as IP addresses are not reused.

The assignment strategies ensure that Node IDs are unique and efficiently managed. The chosen strategy impacts the system’s scalability, performance, and reliability. Different strategies cater to various requirements, balancing simplicity, and complexity.

Below are some common strategies for assigning Node IDs.

1. Random Assignment

In this strategy, Node IDs are assigned randomly. This approach is simple but may require collision detection and handling mechanisms.

When a node joins the network, it generates a random number as its ID. If Node A receives ID 574, and Node B receives ID 894, but Node C generates 574, Node C must generate a new ID.

2. Sequential Assignment

Nodes receive IDs in a sequential order. This method is easy to implement and manage but may lack flexibility.

In a small network, the first node receives ID 1, the second node gets ID 2, and so on. Node A joins and gets ID 1, Node B joins and gets ID 2, and Node C gets ID

3. Hierarchical Assignment

IDs are assigned based on a hierarchy. This strategy is useful for structured systems and helps in managing large networks.

In a data center, each rack of servers might be assigned a unique prefix. Rack 1 could have IDs like 1-1, 1-2, 1-3, and Rack 2 might have 2-1, 2-2, 2-3.

4. Hash-Based Assignment

Nodes generate IDs using hash functions. This method ensures a wide distribution of IDs and reduces collisions.

A node uses its IP address to generate a hash-based ID. If the IP address is “192.168.1.1”, the hash function might produce ID “a4d3c7e1”.

5. Time-Based Assignment

IDs are generated based on the current time. This ensures uniqueness over time and avoids collisions.

When a node joins the network, it generates an ID based on the current timestamp. Node A joins at 10:01:23 and gets ID 100123, Node B joins at 10:01:45 and gets ID 100145.

6. Geographic Assignment

IDs are assigned based on the geographic location of nodes. This is useful for networks spread over large areas.

In a distributed sensor network, sensors in different regions receive IDs with regional prefixes. Sensors in region A get IDs like A-001, A-002, and in region B get B-001, B-002.

7. Role-Based Assignment

Nodes receive IDs based on their roles within the network. This helps in distinguishing nodes by their functions.

In a network, servers might receive IDs with the prefix S (S-001, S-002) and clients might receive C (C-001, C-002).

Node ID collision handling is crucial in distributed systems to ensure each node has a unique identifier. Collisions occur when two nodes receive the same ID, leading to confusion and errors. Effective collision handling ensures system reliability and efficiency.

Below are some strategies for detecting and resolving Node ID collisions.

• Implement mechanisms to detect when an ID collision occurs. This ensures that each node’s ID remains unique.
• Example: When a new node joins and selects an ID, it checks against a central registry. If the ID is already taken, the node generates a new ID.
• Reassign IDs to nodes that experience collisions. This prevents conflicts and ensures smooth operation.
• Example: If Node A and Node B both have ID 101, the system prompts Node B to generate a new ID, avoiding confusion.
• Adjust the ID generation process dynamically to reduce collisions. This improves overall system efficiency and reduces downtime.
• Example: If collisions are frequent, the system might switch to a more complex ID generation method, like using a hash function instead of random numbers.
• Use a central authority to resolve collisions. This authority reassigns IDs and ensures no duplicates exist.
• Example: A central server maintains a list of assigned IDs. When a collision is detected, the server assigns a new ID to the affected node.
• Allow nodes to negotiate among themselves to resolve collisions. This method can reduce the load on a central authority.
• Example: When a collision occurs, the involved nodes communicate and one node voluntarily changes its ID, based on a predefined protocol.
• Implement monitoring and logging to track ID collisions. This helps in identifying patterns and improving collision handling strategies.
• Example: The system logs every collision and resolution event. Administrators review these logs to optimize the ID generation process and reduce future collisions.

Integrating Node IDs with the distributed system architecture is crucial for seamless operation and management. Proper integration ensures efficient communication, data handling, and fault tolerance. Node IDs must be incorporated into various components of the system architecture to achieve these goals.

Below are some key areas where Node IDs play an essential role.

• Node IDs should be embedded within the system’s communication protocols. This ensures that messages are accurately routed and delivered to the correct nodes.
• Example: When Node A sends a message to Node B, it includes B’s Node ID in the message header. This helps the system route the message correctly.
• Integrate Node IDs into data storage systems to ensure data is correctly attributed to the right nodes. This facilitates efficient data retrieval and management.
• Example: Each data record stored in the system includes the Node ID of the node that generated it. This helps in tracking data origin and ensuring data integrity.
• Use Node IDs to enhance security protocols. This helps prevent unauthorized access and spoofing.
• Example: When a node requests access to resources, it must present its Node ID for authentication. This ensures only authorized nodes can access the system.
• Incorporate Node IDs into fault tolerance mechanisms. This helps in identifying and isolating faulty nodes.
• Example: If a node fails, the system uses its Node ID to redistribute its tasks to other nodes. This ensures continuous operation without disruption.
• Use Node IDs to implement efficient load balancing. This ensures that tasks are evenly distributed across nodes.
• Example: The system tracks the load on each node using Node IDs. It then assigns new tasks to the least loaded node, ensuring balanced workload distribution.
• Integrate Node IDs into monitoring and logging systems. This aids in tracking node activities and diagnosing issues.
• Example: The system logs every transaction with the Node ID of the node that performed it. This helps in auditing and troubleshooting.

Below are some examples of Node ID assignment in various contexts.

• Blockchain Networks: In blockchain systems like Bitcoin, each node requires a unique ID. Node IDs help in managing network communication and transaction validation. Each node generates a unique public key, which serves as its identifier. This ensures secure and verifiable transactions across the network.
• Cloud Computing: In cloud environments, unique Node IDs are essential for resource allocation. Each virtual machine (VM) or instance receives a unique identifier upon creation. For example, Amazon Web Services (AWS) assigns each instance an Instance ID like “i-1234567890abcdef0”. This ID helps track usage, manage resources, and perform billing accurately.
• Sensor Networks: In distributed sensor networks, each sensor needs a unique ID for data collection. For instance, in a smart agriculture system, sensors monitor soil moisture and temperature. Each sensor is assigned an ID based on its geographic location, like “Field1-Sensor1” or “Field2-Sensor3”. This helps in identifying the source of data accurately.
• Distributed Databases: Databases like Cassandra assign unique IDs to each node for data partitioning. The system uses a hash-based method to generate these IDs. For example, a node with IP “192.168.1.1” might get an ID generated by hashing its IP. This ensures data is evenly distributed and efficiently managed across the nodes.
• Internet of Things (IoT): In IoT networks, devices must have unique IDs to ensure proper communication. For example, in a smart home system, each device like a thermostat, light bulb, or security camera is assigned a unique ID. This allows the central system to control and monitor each device individually.
• Telecommunications: Telecom networks assign unique IDs to each network device for efficient data routing. For instance, mobile networks use International Mobile Subscriber Identity (IMSI) numbers to identify each subscriber’s device. This ensures accurate call routing and data delivery.

Assigning Node IDs in distributed systems presents several challenges. Ensuring uniqueness, scalability, and efficient management can be complex. Addressing these challenges requires careful planning and implementation of best practices.

Below are some of the common challenges and the best practices to overcome them.

Challenges of Assigning Node ID to Each Node in Distributed Systems

• Scalability Issues: As systems grow, managing a large number of Node IDs becomes difficult. This can lead to increased complexity and potential performance bottlenecks.
• Collision Management: Handling ID collisions effectively is crucial. Frequent collisions can disrupt system operations and reduce efficiency.
• Centralized Bottlenecks: Relying on a central authority for ID assignment can create bottlenecks. This central point of failure can impact the system’s reliability and performance.
• Security Concerns: Ensuring the security of Node IDs is vital. Unauthorized access or spoofing can compromise the system’s integrity.
• Dynamic Environments: In dynamic environments, where nodes frequently join and leave, managing Node IDs becomes more complex. This requires robust and flexible ID management strategies.

Best Practices of Assigning Node ID to Each Node in Distributed Systems

• Use Hybrid Approaches: Combine centralized and decentralized methods for ID assignment. This balances efficiency and scalability, reducing the risk of bottlenecks.
• Implement Collision Detection: Use mechanisms to detect and resolve collisions promptly. This ensures each node has a unique ID and minimizes disruptions.
• Regular Monitoring: Continuously monitor the ID assignment process. Implement logging to track collisions and their resolutions, enabling optimization over time.
• Enhance Security: Secure Node IDs through encryption and authentication. This prevents unauthorized access and ensures the integrity of the system.
• Dynamic Adjustment: Adapt ID generation methods based on system needs. Use more complex methods like hash functions in environments with high collision rates.
• Scalability Planning: Design the system with scalability in mind. Plan for efficient ID management as the system grows, ensuring it can handle increased demands.

Please Login to comment...

Similar reads.

• Distributed System

Improve your Coding Skills with Practice

What kind of Experience do you want to share?