Download Variables and Data Types in C Programming: A Comprehensive Guide and more Lecture notes Computer Science in PDF only on Docsity!
COMPUTER PROGRAMMING PRACTICLE LESSON TWO
printf() and scanf() in C
The printf() and scanf() functions are used for input and output in C language. Both functions are inbuilt library functions, defined in stdio.h (header file).
printf() function
The printf() function is used for output. It prints the given statement to the console. The syntax of printf() function is given below:
- printf("format string",argument_list); The format string can be %d (integer), %c (character), %s (string), %f (float) etc.
scanf() function
The scanf() function is used for input. It reads the input data from the console.
- scanf("format string",argument_list); Program to print cube of given number Let's see a simple example of c language that gets input from the user and prints the cube of the given number.
- #include<stdio.h>
- int main(){
- int number;
- printf("enter a number:");
- scanf("%d",&number);
- printf("cube of number is:%d ",numbernumbernumber);
- return 0;
- }
Output
enter a number: cube of number is: The scanf("%d",&number) statement reads integer number from the console and stores the given value in number variable. The printf("cube of number is:%d ",numbernumbernumber)** statement prints the cube of number on the console.
Program to print sum of 2 numbers
Let's see a simple example of input and output in C language tha t prints addition of 2 numbers.
- #include<stdio.h>
- int main(){
- int x=0,y=0,result=0;
- printf("enter first number:");
- scanf("%d",&x);
- printf("enter second number:");
- scanf("%d",&y);
- result=x+y;
- printf("sum of 2 numbers:%d ",result);
- return 0;
- }
Output enter first number: enter second number: sum of 2 numbers:
Variables in C
A variable is the name of the memory location. It is used to store information. Its value can be altered and reused several times. It is a way to represent memory location through symbols so that it can be easily identified. Variables are key building elements of the C programming language used to store and modify data in computer programs. A variable is a designated memory region that stores a specified data type value. Each variable has a unique identifier , its name , and a data type describing the type of data it may hold.
Syntax:
The syntax for defining a variable in C is as follows:
- data_type variable_name; Here, o data_type: It represents the type of data the variable can hold. Examples of data types in C include int (integer), float (a floating-point number), char (character), double (a double- precision floating-point number), o variable_name: It is the identifier for the variable, i.e., the name you give to the variable to access its value later in the program. The variable name must follow specific rules, like starting with a letter or underscore and consisting of letters , digits, and underscores. For example, to declare the integer variable age :
- int age; It declares an integer variable named age without assigning it a specific value. Variables can also be initialized at the time of declaration by assigning an initial value to them. For instance:
- int count = 0; Here, the variable count is declared an integer and initialized with 0. Note: Variables should be defined before they are used within the program. The scope of a variable determines where it is accessible. Variables declared inside a function or block are considered local variables , while declared outside any function are considered global variables.
Syntax:
Let us see the syntax to declare a variable:
- type variable_list; An example of declaring the variable is given below:
- int a; 2. float b; 3. char c; Here, a, b, and c are variables. The int, float, and char are the data types. We may also provide values while defining variables, as shown below:
- int a=20,b=30;//declaring 2 variable of integ er type 2. float f=20.9; 3. char c='A';
The general syntax for variable declaration is
- data_type variable_name;
Example of variable declaration:
- #include <stdio.h>
- int main() {
- // Variable declaration
- int age;
- float salary;
- char initial;
- return 0;
- }
2. Variable Definition:
The process of reserving memory space for the variable to keep its contents during program execution is known as a variable definition. It is based on the data type and connects the variable name with a particular memory address of sufficient size. A variable in C can be declared and defined in the same statement, although they can also be separated if necessary.
Example of variable definition:
- #include <stdio.h>
- int main() {
- // Variable definition
- int age = 25;
- float salary = 2500.5;
- char initial = 'J';
- return 0;
- }
3. Variable Initialization:
Variable declaration is the act of informing the compiler about the existence and data type of a variable. It informs the compiler that a variable with a specific name and data type will be used in the program, but that memory for the variable still needs to be allocated. Not explicitly initialized variables will contain garbage/random data that may result in unexpected program behavior.
Example of variable initialization:
- #include <stdio.h>
- int main() {
- // Variable definition and initialization
- int age = 25;
- float salary = 2500.5;
- char initial = 'J';
- // Later in the program, you can change the value of the variable
- age = 30;
- salary = 3000.0;
- return 0;
- } In the example above, we have variable age, salary , and initial declarations. After that, we define these variables and initialize them with initial values (e.g., age = 25). Later in the program, we can modify the values of these variables (e.g., age = 30).
Types of Variables in C
There are many types of variables in c:
- local variable
- global variable
- static variable
- automatic variable
- external variable
Local Variable
A variable that is declared inside the function or block is called a local variable. It must be declared at the start of the block.
- void function1(){
- int x=10;//local variable
You must have to initialize the local variable before it is used.
Global Variable
A variable that is declared outside the function or block is called a global variable. Any function can change the value of the global variable. It is available to all the functions. It must be declared at the start of the block.
- int value=20;//global variable
- void function1(){
- int x=10;//local variable
- }
Static Variable
A variable that is declared with the static keyword is called static variable. It retains its value between multiple function calls.
- void function1(){
- int x=10;//local variable
- static int y=10;//static variable
- x=x+1;
- y=y+1;
- printf("%d,%d",x,y);
- } If you call this function many times, the local variable will print the same value for each function call, e.g, 11,11,11 and so on. But the static variable will print the incremented value in each function call, e.g. 11, 12, 13 and so on.
Automatic Variable
All variables in C that are declared inside the block, are automatic variables by default. We can explicitly declare an automatic variable using auto keyword.
- void main(){
- int x=10;//local variable (also automatic)
- auto int y=20;//automatic variable
- }
External Variable
We can share a variable in multiple C source files by using an external variable. To declare an external variable, you need to use extern keyword.
Basic Data Types
The basic data types are integer-based and floating-point based. C language supports both signed and unsigned literals. The memory size of the basic data types may change according to 32 or 64-bit operating system. Let's see the basic data types. Its size is given according to 32-bit architecture. Data Types Memory S ize Range char 1 byte −128 to 127 signed char 1 byte −128 to 127 unsigned char 1 byte 0 to 255 short 2 byte −32,768 to 32, signed short 2 byte −32,768 to 32, unsigned short 2 byte 0 to 65, int 2 byte −32,768 to 32, signed int 2 byte −32,768 to 32, unsigned int 2 byte 0 to 65, short int 2 byte −32,768 to 32, signed short int 2 byte −32,768 to 32, unsigned short int 2 byte 0 to 65, long int 4 byte - 2,147,483,648 to 2,147,483, signed long int 4 byte - 2,147,483,648 to 2,147,483, unsigned long int 4 byte 0 to 4,294,967, float 4 byte double 8 byte long double 10 byte
Int:
Integers are entire numbers without any fractional or decimal parts, and the int data type is used to represent them. It is frequently applied to variables that include values , such as counts, indices , or other numerical numbers. The int data type may represent both positive and negative numbers because it is signed by default. An int takes up 4 bytes of memory on most devices, allowing it to store values between around - 2 billion and +2 billion.
Char:
Individual characters are represented by the char data type. Typically used to hold ASCII or UTF- 8 encoding scheme characters , such as letters, numbers, symbols , or commas. There are 256 characters that can be represented by a single char, which takes up one byte of memory. Characters such as 'A', 'b', '5', or '$' are enclosed in single quotes.
Float:
To represent integers, use the floating data type. Floating numbers can be used to represent fractional units or numbers with decimal places. The float type is usually used for variables that require very good precision but may not be very precise. It can store values with an accuracy of about 6 decimal places and a range of about 3.4 x 1038 in 4 bytes of memory.
Double:
Use two data types to represent two floating integers. When additional precision is needed, such as in scientific calculations or financial applications, it provides greater accuracy compared to float. Double type , which uses 8 bytes of memory and has an accuracy of about 15 decimal places, yields larger values. C treats floating point numbers as doubles by default if no explicit type is supplied.
- int age = 25;
- char grade = 'A';
- float temperature = 98.6;
- double pi = 3.14159265359; In the example above, we declare four variables: an int variable for the person's age, a char variable for the student's grade, a float variable for the temperature reading, and two variables for the number pi.
Derived Data Type
Beyond the fundamental data types, C also supports derived data types, including arrays, pointers, structures, and unions. These data types give programmers the ability to handle heterogeneous data, directly modify memory, and build complicated data structures.
Array:
An array, a derived data type , lets you store a sequence of fixed-size elements of the same type. It provides a mechanism for joining multiple targets of the same data under the same name. The index is used to access the elements of the array, with a 0 index for the first entry. The size of the array is fixed at declaration time and cannot be changed during program execution. The array components are placed in adjacent memory regions. Here is an example of declaring and utilizing an array:
- #include <stdio.h>
- int main() {
- int numbers[5]; // Declares an integer array wit h a size of 5 elements
- // Assign values to the array elements
- numbers[0] = 10;
- numbers[1] = 20;
- numbers[2] = 30;
- numbers[3] = 40;
- numbers[4] = 50;
- // Display the values stored in the array
- printf("Values in the array: ");
- for ( int i = 0; i < 5; i++) {
- printf("%d ", numbers[i]);
- }
- printf("\n");
- return 0;
- }
Output:
Values in the array: 10 20 30 40 50
Output: Name: John Doe Age: 30 Height: 1.
Union:
A derived data type called a union enables you to store various data types in the samememory address. In contrast to structures, where each member has a separate memory space, members of a union all share a single memory space. A value can only be held by one member of a union at any given moment. When you need to represent many data types interchangeably, unions come in handy. Like structures, you can access the members of a union by using the dot (.) operator. Here is an example of a union being declared and used:
- #include <stdio.h>
- // Define a union representing a numeric value
- union NumericValue {
- int intValue;
- float floatValue;
- char stringValue[20];
- };
- int main() {
- // Declare a variable of type union NumericVal ue
- union NumericValue value;
- // Assign a value to the union
- value.intValue = 42;
- // Accessing the union members
- printf("Integer Value: %d\n", value.intValue);
- // Assigning a different value to the union
- value.floatValue = 3.14;
- // Accessing the union members
- printf("Float Value: %.2f\n", value.floatValue);
- return 0;
- } Output: Integer Value: 42 Float Value: 3.
Enumeration Data Type
A set of named constants or enumerators that represent a collection of connected values can be defined in C using the enumeration data type (enum). Enumerations give you the means to give names that make sense to a group of integral values, which makes your code easier to read and maintain. Here is an example of how to define and use an enumeration in C:
- #include <stdio.h>
- // Define an enumeration for days of the week
- enum DaysOfWeek {
- Monday,
- Tuesday,
- Wednesday,
- Thursday,
- Friday,
- Saturday,
- Sunday
- };
- int main() {
- // Declare a variable of type enum DaysOfWek
- enum DaysOfWeek today;
- // Assign a value from the enumeration
- today = Wednesday;
- // Accessing the enumeration value
- printf("Today is %d\n", today);
- return 0;
- }
Output: Today is 2
Void Data Type
The void data type in the C language is used to denote the lack of a particular type. Function return types, function parameters , and pointers are three situations where it is frequently utilized.
Function Return Type:
A void return type function does not produce a value. A void function executes a task or action and ends rather than returning a value. Example:
- void printHello() { printf("Hello, world!\n"); }
Function Parameters:
The parameter void can be used to indicate that a function accepts no arguments. Example:
- void processInput( void ) { /* Function logic */ }
Pointers:
Any address can be stored in a pointer of type _void_* , making it a universal pointer. It offers a method for working with pointers to ambiguous or atypical types. Example:
1. void dataPtr;* The void data type is helpful for defining functions that don't accept any arguments when working with generic pointers or when you wish to signal that a function doesn't return a value. It is significant to note that while _void_* can be used to build generic pointers, void itself cannot be declared as a variable type. Here is a sample of code that shows how to utilize void in various situations:
- #include <stdio.h>
- // Function with void return type
- void printHello() {
- printf("Hello, world!\n");
- }
- // Function with void parameter
- void processInput( void ) {
- printf("Processing input...\n");
- }
- int main() {
- // Calling a void function
- printHello();
- // Calling a function with void parameter
- processInput();
- // Using a void pointer
- int number = 10;
- void * dataPtr = &number;
- printf("Value of number: %d\n", *( int *)dataPtr);
- return 0;
- } Output: Hello, world! Processing input... Value of number: 10
