C Programming/Variables
Objective[edit | edit source] In this lesson, you will learn about:
|
Introduction[edit | edit source]The most fundamental concept in C (and most other programming languages) is the variable. A variable is like a container. You can store things in it for later use, particularly numbers. The concept of a variable is borrowed from mathematics. A statement such as x = 1 // This is a variable statement in Math, not in C programming stores the value 1 in the variable x. In C, it is much the same. To assign a value to a variable, you must declare it. You declare a variable by specifying it's data type and name, like so: data_type variable_name;
The programmer may combine declaration and assignment, which is known as initialization. Here is the variable x being declared and initialized: int x = 1;
Every variable has a name. Whenever you want to use a variable, you specify what variable you want to use by using its name. The set of rules, ways and syntax we used to name a variable, as well as other programming terminology like function, source files,... is known as naming convention. In C, a variable name can be any combination of letters, digits, and underscores (the _ character) you want, so long as the first character is not a digit. Picking a good name makes your program much easier to read and understand. A good variable name describes exactly what the data it holds is. For example, if a variable stores the current temperature, you can name it current_temperature. If it stores the score of a video game , name it player_score. However, putting the full words for a variable, like current_temperature, can make the variable's name to be be very long when the situation involved with this variable is complicated. That's why we are also expected to use abbreviation in this case. For example, current_temperature could be abbreviated to cur_tem. However, you should also be careful with abbreviation, as it might save you a bit of typing, but it can remove clarity from your code in some ways. You should really only use abbreviations if there is only 1 possible interpretation for it, and if its obvious what that interpretation is by the context of the program. For example if using the abbreviated word temp, does it mean temperature or temporary ? Things can even get more confuse when your variable need to stored the temporary temperature, should it be temp_tem ? In those situations, it's recommended to use the full names, its not that many more keys. Variable naming convention provides one more guideline with the syntax to name the variables. It involves with the use of capitalized and uncapitalized letters, as well as the underscore symbol. This results in three naming conventions: under_score, camelCase, and PascalCase. A few examples of underscore: current_temperature, temp_variable, this_is_a_long_name,... A few examples of the camelCase: currentTemperature, tempVariable, thisIsALongName,... A few examples of the PascalCase: CurrentTemperature, TempVariable, ThisIsALongName,... All those ways are fine, it's just a matter of preference/readability and also depends on the coding standard or the naming convention expected in your project. Data Types and Qualifiers[edit | edit source]Data types and name of a variable combine to completely describe the variable, where the variable's data type describes what kind of data it holds. C is strongly typed, which means that variables must be explicitly assigned a data type. Data types indicate the type of data a variable can hold. When a variable is defined, a memory location will be assigned to the newly defined variable and it will also define the type of data that memory location will hold. C has 4 basic data types:
In addition to basic data types C also defines certain qualifiers to these data types. Qualifiers are used to make variable declaration more specific to variable uses. Qualifiers available in the C language are:
Using these qualifiers, basic data types can be flavoured in many ways as shown in the table below. Note that the values given are acceptable minimum magnitudes defined by the C Standard - each implementation will define values greater or equal in magnitude.
Note: If a variable goes beyond its range, like defining an int in a 16-bit system to be larger than 32,767, you'll end up with a negative number while you expect a positive one. C type qualifiers add special properties to the variables being declared. C provides the following two keywords:
Note:
Storage Classes[edit | edit source]Storage classes define the longevity and scope of variables and functions. There are two types of storage classes: automatic and static. There are several storage class specifiers:
Storage classes can be remembered easily by remembering mnemonic RASE, i.e., register, auto, static, and extern. Example: the arithmetic mean of two numbers[edit | edit source]The following source code is compiled with GCC: #include <stdio.h>
void main(void)
{
int a, b;
float avg; // data type
printf("Enter the a:");
scanf("%d", &a);
printf("Enter the b:");
scanf("%d", &b);
avg = (a + b) / 2; // expression
printf("%f", avg);
getch(); // getchar() may work instead
return 0;
}
Expressions[edit | edit source]To manipulate the variable, ‘a’, declared and defined in the previous section, an expression is needed. By definition, an expression, in C, is an interpreted combination of values, variables, operators or functions. There are a number of operators available including addition, ‘+’, subtraction, ‘-‘, division ‘/’, and multiplication ‘*’. In an expression, the variable name on the left side of the assignment operator represents the area of memory that stores interpreted results. Variable and constants on the right side of the assignment operator are interpreted to determine a result prior to assignment. Note these definitions and declarations: int a;
int b;
a = 0;
b = 8;
What follows is a statement which manipulates storage in memory (an expression becomes a statement when it is followed by a semicolon): a = b + 24;
In this statement, the constant ‘24’, is added to the value stored in the variable ‘b’. The result of that calculation, then, is assigned to a memory location, symbolically represented by the variable ‘a’. After the interpretation of the statement, the variable 'a' is assigned the value 32. Type conversion[edit | edit source]Type conversion is simply conversion from one type to another one. There are two types of type conversion:
Implicit type conversion[edit | edit source]
C has the concept of data types: int x = 10; // integer x
char y = 'a'; // character c
// y implicitly converted to int. ASCII
// value of 'a' is 97
x = x + y;
// x is implicitly converted to float
float z = x + 1.0;
printf("x = %d\n", x);//107
printf("y = %c\n", y);//a
printf("z = %f\n", z);//108.0000
Implicit casting for float to int: int b = 3.1;
printf("%d \n", b); //3
printf("%f \n", b); //0.0
Implicit casting in printf() for float to int: float c = 3.1;
printf("%d \n", c); //-1073741824
Implicit casting during calculation: int a = (998/1024)*100; // a = 0
Explicit type conversion[edit | edit source]Explicit Type Conversion, which is user-defined, allows user to typecast the result to make it of a particular data type. Syntax: (type) expression
double to int[edit | edit source]double x = 1.2;
// Explicit conversion from double to int
int sum = (int)x + 1;
printf("sum = %d\n", sum);//2
float to int[edit | edit source]int a = (int) 12.9;
printf("%d \n", a); //12
printf("%f \n", a); //0
int to float[edit | edit source]float a = (float) 3;
printf("%d \n", a); //0
printf("%f \n", a); //3.000
Creating your own storage types[edit | edit source]Beside using the primitive data type, C allows to create your own storage data type. There are 2 ways to do this: typedefs and enums enum[edit | edit source]enum is short for enumeration. An enum allows you to use a different name for one of the built-in storage types, and simultaneously defines what the legal values for the enum are. Take this example for enum: enum {value0 = 10, value1, value2, value3, value4 = 10, value5 = 16, value6};
enum {value7, value8, value9, value10, value11=1, value12=12, value13};
printf("%d, %d, %d, %d, %d, %d, %d\n", value0 , value1, value2, value3, value4, value5, value6);//10, 11, 12, 13, 10, 16, 17
printf("%d, %d, %d, %d, %d, %d, %d\n", value7 , value8, value9, value10, value11, value12, value13);//0, 1, 2, 3, 1, 12, 13
Note:
object of enum enum enum_object {value0 = 10, value1, value2, value3, value4 = 10, value5 = 16, value6};
enum enum_object enum_object_1;
printf("%d\n", enum_object_1);//0; enum_object_1 value now is not set
enum_object_1 = value0;
printf("%d\n", enum_object_1);//10
enum_object_1 = value1;
printf("%d\n", enum_object_1);//11
typedef[edit | edit source]typedef is short for type definition. A typedef basicly allows you to use a different name for one of the built-in storage types. You can declare a typedef by using: typedef storage_type real_type;
Take this example for typedef: #include <stdio.h>
typedef int integer;
integer displayFunction();
int main() {
integer a = 19;
printf("%d\n", a); //19
printf("%d\n", displayFunction()); //4
}
integer displayFunction(){
return 4;
}
Naming the variable[edit | edit source]As the final part of this lecture, we're going to review the naming for the variable again. Since naming is by far the most important thing to take away from this lesson, Choosing good names is one of the most important thing to do when writing code. It will do more for making your code easy to read and understand than almost anything else. It's important to get in good habits now, too many students who first learn to code and use x and y for all their variables. Lets use an example. Which of these give you the most information: int x;
int myHeight;
inches x;
inches myHeight;
The first tells you nothing. The second tells you what's being stored, but not how its represented (inches? centimeters? microns?). The third tells you how something is being stored, but not what it is (you can use typedef to define that inches type, i.e typedef int inches). The final one tells us not only what's being stored, but also how it's represented. Imagine a large program with 10,000 variables, you might prefer the the fourth way, while in a small program, the second way can be used. External resources[edit | edit source] |
Assignments[edit | edit source]
|