C guide download

If you try to use a hexadecimal value that is outside the range of characters, you will get a compile-time error. A real number constant is a value that represents a fractional floating point number. Either the integer part or the fractional part may be omitted, but not both.

In the third assignment statement, the integer constant 4 is automatically converted from an integer value to a double value. Real number constants can also be followed by e or E , and an integer exponent. The exponent can be either positive or negative. You can append a letter to the end of a real number constant to cause it to be of a particular type.

If you append the letter F or f to a real number constant, then its type is float. If you append the letter L or l , then its type is long double. If you do not append any letters, then its type is double. A string constant is a sequence of zero or more characters, digits, and escape sequences enclosed within double quotation marks.

Strings are stored as arrays of characters, with no inherent size attribute. The null termination character lets string-processing functions know where the string ends.

Adjacent string constants are concatenated combined into one string, with the null termination character added to the end of the final concatenated string. A string cannot contain double quotation marks, as double quotation marks are used to enclose the string. You can use any of the escape sequences that can be used as character constants in strings.

Here are some example of string constants:. Adjacent strings are automatically concatenated, so you can also have string constants span multiple lines by writing them as separate, adjacent, strings. For example:. An operator is a special token that performs an operation, such as addition or subtraction, on either one, two, or three operands. Full coverage of operators can be found in a later chapter.

See Expressions and Operators. A separator separates tokens. White space see next section is a separator, but it is not a token. The other separators are all single-character tokens themselves:. White space is the collective term used for several characters: the space character, the tab character, the newline character, the vertical tab character, and the form-feed character.

White space is ignored outside of string and character constants , and is therefore optional, except when it is used to separate tokens. This means that. Although you must use white space to separate many tokens, no white space is required between operators and operands, nor is it required between other separators and that which they separate.

In string constants, spaces and tabs are not ignored; rather, they are part of the string. The integer data types range in size from at least 8 bits to at least 32 bits. The C99 standard extends this range to include integer sizes of at least 64 bits. You should use integer types for storing whole number values and the char data type for storing characters.

The sizes and ranges listed for these types are minimums; depending on your computer platform, these sizes and ranges may be larger. While these ranges provide a natural ordering, the standard does not require that any two types have a different range. For example, it is common for int and long to have the same range. The standard even allows signed char and long to have the same range, though such platforms are very unusual. The first line declares an integer named foo but does not define its value; it is left uninitialized, and its value should not be assumed to be anything in particular.

There are three data types that represent fractional numbers. While the sizes and ranges of these types are consistent across most computer systems in use today, historically the sizes of these types varied from system to system.

As such, the minimum and maximum values are stored in macro definitions in the library header file float. All floating point data types are signed; trying to use unsigned float , for example, will cause a compile-time error. The first line declares a float named foo but does not define its value; it is left uninitialized, and its value should not be assumed to be anything in particular. The real number types provided in C are of finite precision, and accordingly, not all real numbers can be represented exactly.

Most computer systems that GCC compiles for use a binary representation for real numbers, which is unable to precisely represent numbers such as, for example, 4. GCC introduced some complex number types as an extension to C Similar features were introduced in C99 1 , but there were a number of differences. We describe the standard complex number types first. Other functions are also provided, as shown in this example:. This example creates a complex floating point variable a , and defines its real part as 4 and its imaginary part as 3.

Then, the real part is assigned to the floating point variable b , and the imaginary part is assigned to the floating point variable c. An enumeration is a custom data type used for storing constant integer values and referring to them by names.

By default, these values are of type signed int ; however, you can use the -fshort-enums GCC compiler option to cause the smallest possible integer type to be used instead. Both of these behaviors conform to the C89 standard, but mixing the use of these options within the same program can produce incompatibilities.

You define an enumeration using the enum keyword, followed by the name of the enumeration this is optional , followed by a list of constant names separated by commas and enclosed in braces , and ending with a semicolon. That example defines an enumeration, fruit , which contains four constant integer values, grape , cherry , lemon , and kiwi , whose values are, by default, 0, 1, 2, and 3, respectively.

You can also specify one or more of the values explicitly:. That example defines banana to be , and the remaining values are incremented by 1: apple is , blueberry is , and mango is Unless specified otherwise, an enumeration value is equal to one more than the previous value and the first value defaults to 0. In that example, kumquat is 0, raspberry is 1, peach is 2, and plum is 4. You can declare variables of an enumeration type both when the enumeration is defined and afterward.

Although such variables are considered to be of an enumeration type, you can assign them any value that you could assign to an int variable, including values from other enumerations. Furthermore, any variable that can be assigned an int value can be assigned a value from an enumeration.

However, you cannot change the values in an enumeration once it has been defined; they are constant values. Enumerations are useful in conjunction with the switch statement, because the compiler can warn you if you have failed to handle one of the enumeration values.

Using the example above, if your code handles banana , apple and mango only but not blueberry , GCC can generate a warning. A union is a custom data type used for storing several variables in the same memory space. Although you can access any of those variables at any time, you should only read from one of them at a time—assigning a value to one of them overwrites the values in the others.

You declare each member of a union just as you would normally declare a variable—using the data type followed by one or more variable names separated by commas, and ending with a semicolon. Then end the union definition with a semicolon after the closing brace.

You should also include a name for the union between the union keyword and the opening brace. Here is an example of defining a simple union for holding an integer value and a floating point value:. That defines a union named numbers , which contains two members, i and f , which are of type int and float , respectively. You can declare variables of a union type when both you initially define the union and after the definition, provided you gave the union type a name.

You can declare variables of a union type when you define the union type by putting the variable names after the closing brace of the union definition, but before the final semicolon.

You can declare more than one such variable by separating the names with commas. You can declare variables of a union type after you define the union by using the union keyword and the name you gave the union type, followed by one or more variable names separated by commas.

The f member is left alone. Another way to initialize a union member is to specify the name of the member to initialize. This way, you can initialize whichever member you want to, not just the first one. There are two methods that you can use—either follow the member name with a colon, and then its value, like this:. You can also initialize a union member when you declare the union variable during the definition:. You can access the members of a union variable using the member access operator.

You put the name of the union variable on the left side of the operator, and the name of the member on the right side. Notice in that example that giving a value to the f member overrides the value stored in the i member. This size of a union is equal to the size of its largest member. Consider the first union example from this section:. The size of the union data type is the same as sizeof float , because the float type is larger than the int type.

A structure is a programmer-defined data type made up of variables of other data types possibly including other structure types. You declare each member of a structure just as you would normally declare a variable—using the data type followed by one or more variable names separated by commas, and ending with a semicolon.

Then end the structure definition with a semicolon after the closing brace. You should also include a name for the structure in between the struct keyword and the opening brace. Here is an example of defining a simple structure for holding the X and Y coordinates of a point:. That defines a structure type named struct point , which contains two members, x and y , both of which are of type int.

Structures and unions may contain instances of other structures and unions, but of course not themselves. It is possible for a structure or union type to contain a field which is a pointer to the same type see Incomplete Types. You can declare variables of a structure type when both you initially define the structure and after the definition, provided you gave the structure type a name.

You can declare variables of a structure type when you define the structure type by putting the variable names after the closing brace of the structure definition, but before the final semicolon. You can declare variables of a structure type after defining the structure by using the struct keyword and the name you gave the structure type, followed by one or more variable names separated by commas.

You can initialize the members of a structure type to have certain values when you declare structure variables. If you do not initialize a structure variable, the effect depends on whether it has static storage see Storage Class Specifiers or not. One way to initialize a structure is to specify the values in a set of braces and separated by commas. Those values are assigned to the structure members in the same order that the members are declared in the structure in definition.

Another way to initialize the members is to specify the name of the member to initialize. This way, you can initialize the members in any order you like, and even leave some of them uninitialized. There are two methods that you can use. Here, x is initialized with 5, y is initialized with 0, and p is initialized with NULL. The rule here is that y and p are initialized just as they would be if they were static variables.

That example defines the rectangle structure to consist of two point structure variables. Then it declares one variable of type struct rectangle and initializes its members.

Since its members are structure variables, we used an extra set of braces surrounding the members that belong to the point structure variables. However, those extra braces are not necessary; they just make the code easier to read.

You can access the members of a structure variable using the member access operator. You put the name of the structure variable on the left side of the operator, and the name of the member on the right side. You can also access the members of a structure variable which is itself a member of a structure variable.

You can create structures with integer members of nonstandard sizes, called bit fields. You do this by specifying an integer int , char , long int , etc. Notice that these bit fields were declared as unsigned int ; had they been signed integers, then their ranges would have been from -2 to 1, and from -8 to 7, respectively. Bit fields can be specified without a name in order to control which actual bits within the containing unit are used.

However, the effect of this is not very portable and it is rarely useful. You can also specify a bit field of size 0, which indicates that subsequent bit fields not further bit fields should be packed into the unit containing the previous bit field. This is likewise not generally useful. The size of a structure type is equal to the sum of the size of all of its members, possibly including padding to cause the structure type to align to a particular byte boundary.

The details vary depending on your computer platform, but it would not be atypical to see structures padded to align on four- or eight-byte boundaries.

This is done in order to speed up memory accesses of instances of the structure type. If you wish to explicitly omit padding from your structure types which may, in turn, decrease the speed of structure memory accesses , then GCC provides multiple methods of turning packing off.

The quick and easy method is to use the -fpack-struct compiler option. For more details on omitting packing, please see the GCC manual which corresponds to your version of the compiler. An array is a data structure that lets you store one or more elements consecutively in memory. In C, array elements are indexed beginning at position zero, not one. You declare an array by specifying the data type for its elements, its name, and the number of elements it can store.

Here is an example that declares an array that can store ten integers:. As a GNU extension, the number of elements can be as small as zero. Zero-length arrays are useful as the last element of a structure which is really a header for a variable-length object:. Another GNU extension allows you to declare an array size using variables, rather than only constants.

For example, here is a function definition that declares an array using its parameter as the number of elements:. You can initialize the elements in an array when you declare it by listing the initializing values, separated by commas, in a set of braces.

Here is an example:. For example, this code initializes the first three elements as specified, and then initializes the last two elements to a default value of zero:. When using either ISO C99, or C89 with GNU extensions, you can initialize array elements out of order, by specifying which array indices to initialize.

To do this, include the array index in brackets, and optionally the assignment operator, before the value. When using GNU extensions, you can initialize a range of elements to the same value, by specifying the first and last indices, in the form [ first ] That initializes elements 0 through 9 to 1, elements 10 through 98 to 2, and element 99 to 3.

If you initialize every element of an array, then you do not have to specify its size; its size is determined by the number of elements you initialize. Alternately, if you specify which elements to initialize, then the size of the array is equal to the highest element number initialized, plus one. In that example, only four elements are initialized, but the last one initialized is element number 99, so there are elements.

You can access the elements of an array by specifying the array name, followed by the element index, enclosed in brackets. Remember that the array elements are numbered starting with zero. That assigns the value 5 to the first element in the array, at position zero. You can treat individual array elements like variables of whatever data type the array is made up of.

For example, if you have an array made of a structure data type, you can access the structure elements like this:. You do this by adding an extra set of brackets and array lengths for every additional dimension you want your array to have. For example, here is a declaration for a two-dimensional array that holds five elements in each dimension a two-element array consisting of five-element arrays :.

You can use an array of characters to hold a string see String Constants. The array may be built of either signed or unsigned characters. When you declare the array, you can specify the number of elements it will have. That number will be the maximum number of characters that should be in the string, including the null character used to end the string. If you choose this option, then you do not have to initialize the array when you declare it.

Alternately, you can simply initialize the array to a value, and its size will then be exactly large enough to hold whatever string you used to initialize it. There are two different ways to initialize the array. You can specify of comma-delimited list of characters enclosed in braces, or you can specify a string literal enclosed in double quotation marks. Note that if you initialize a string using an array of individual characters, then the null character is not guaranteed to be present.

It might be, but such an occurrence would be one of chance, and should not be relied upon. After initialization, you cannot assign a new string literal to an array using the assignment operator.

For example, this will not work :. However, there are functions in the GNU C library that perform operations including copy on string arrays. You can also change one character at a time, by accessing individual string elements as you would any other array:. It is possible for you to explicitly state the number of elements in the array, and then initialize it using a string that has more characters than there are elements in the array.

This is not a good thing. The larger string will not override the previously specified size of the array, and you will get a compile-time warning. Since the original array size remains, any part of the string that exceeds that original size is being written to a memory location that was not allocated for it. You can also initialize the first members of the elements of a number array:.

After initialization, you can still access the union members in the array using the member access operator. You put the array name and element number enclosed in brackets to the left of the operator, and the member name to the right.

You can also initialize the elements of a structure array:. As with initializing structures which contain structure members, the additional inner grouping braces are optional. But, if you use the additional braces, then you can partially initialize some of the structures in the array, and fully initialize others:.

In that example, the first element of the array has only its x member initialized. Because of the grouping braces, the value 4 is assigned to the x member of the second array element, not to the y member of the first element, as would be the case without the grouping braces. After initialization, you can still access the structure members in the array using the member access operator.

Pointers hold memory addresses of stored constants or variables. For any data type, including both primitive types and custom types, you can create a pointer that holds the memory address of an instance of that type. You declare a pointer by specifying a name for it and a data type. The data type indicates of what type of variable the pointer will hold memory addresses.

To declare a pointer, include the indirection operator see Pointer Operators before the identifier. Here is the general form of a pointer declaration:. The Redistributable package architecture must match your app's target architecture. The Redistributable version must be at least as recent as the MSVC build toolset used to build your app.

We recommend you use the latest Redistributable available for your version of Visual Studio, with some exceptions noted below. We recommend you install this version for all applications created using Visual Studio , , , or Download other languages and versions, including versions for long term servicing release channels LTSC , from my.

Some of the downloads that are mentioned in this article are currently available on my. Make sure to log in by using a Visual Studio Subscription account so that you can access the download links.

If you're asked for credentials, use your existing Visual Studio subscription account. Repeats a statement or group of statements while a given condition is true. It tests the condition before executing the loop body. Executes a sequence of statements multiple times and abbreviates the code that manages the loop variable. It is more like a while statement, except that it tests the condition at the end of the loop body.

Loop control statements change execution from its normal sequence. When execution leaves a scope, all automatic objects that were created in that scope are destroyed. Terminates the loop or switch statement and transfers execution to the statement immediately following the loop or switch.

Causes the loop to skip the remainder of its body and immediately retest its condition prior to reiterating. A loop becomes an infinite loop if a condition never becomes false. The for loop is traditionally used for this purpose. Since none of the three expressions that form the 'for' loop are required, you can make an endless loop by leaving the conditional expression empty.

When the conditional expression is absent, it is assumed to be true. You may have an initialization and increment expression, but C programmers more commonly use the for ;; construct to signify an infinite loop.

A function is a group of statements that together perform a task. Every C program has at least one function, which is main , and all the most trivial programs can define additional functions. You can divide up your code into separate functions. How you divide up your code among different functions is up to you, but logically the division is such that each function performs a specific task. A function declaration tells the compiler about a function's name, return type, and parameters.

A function definition provides the actual body of the function. The C standard library provides numerous built-in functions that your program can call. For example, strcat to concatenate two strings, memcpy to copy one memory location to another location, and many more functions.

A function definition in C programming consists of a function header and a function body. Some functions perform the desired operations without returning a value. The function name and the parameter list together constitute the function signature.

When a function is invoked, you pass a value to the parameter. This value is referred to as actual parameter or argument. The parameter list refers to the type, order, and number of the parameters of a function. Parameters are optional; that is, a function may contain no parameters. Given below is the source code for a function called max. A function declaration tells the compiler about a function name and how to call the function.

The actual body of the function can be defined separately. Function declaration is required when you define a function in one source file and you call that function in another file. In such case, you should declare the function at the top of the file calling the function. While creating a C function, you give a definition of what the function has to do. To use a function, you will have to call that function to perform the defined task.

When a program calls a function, the program control is transferred to the called function. A called function performs a defined task and when its return statement is executed or when its function-ending closing brace is reached, it returns the program control back to the main program. To call a function, you simply need to pass the required parameters along with the function name, and if the function returns a value, then you can store the returned value.

We have kept max along with main and compiled the source code. If a function is to use arguments, it must declare variables that accept the values of the arguments. These variables are called the formal parameters of the function. Formal parameters behave like other local variables inside the function and are created upon entry into the function and destroyed upon exit.

This method copies the actual value of an argument into the formal parameter of the function. In this case, changes made to the parameter inside the function have no effect on the argument. This method copies the address of an argument into the formal parameter. Inside the function, the address is used to access the actual argument used in the call.

This means that changes made to the parameter affect the argument. By default, C uses call by value to pass arguments. In general, it means the code within a function cannot alter the arguments used to call the function. A scope in any programming is a region of the program where a defined variable can have its existence and beyond that variable it cannot be accessed. Let us understand what are local and global variables, and formal parameters.

Variables that are declared inside a function or block are called local variables. They can be used only by statements that are inside that function or block of code.

Local variables are not known to functions outside their own. The following example shows how local variables are used. Here all the variables a, b, and c are local to main function. Global variables are defined outside a function, usually on top of the program. Global variables hold their values throughout the lifetime of your program and they can be accessed inside any of the functions defined for the program.

A global variable can be accessed by any function. That is, a global variable is available for use throughout your entire program after its declaration.

The following program show how global variables are used in a program. A program can have same name for local and global variables but the value of local variable inside a function will take preference.

Formal parameters, are treated as local variables with-in a function and they take precedence over global variables. When a local variable is defined, it is not initialized by the system, you must initialize it yourself.

It is a good programming practice to initialize variables properly, otherwise your program may produce unexpected results, because uninitialized variables will take some garbage value already available at their memory location. Arrays a kind of data structure that can store a fixed-size sequential collection of elements of the same type.

An array is used to store a collection of data, but it is often more useful to think of an array as a collection of variables of the same type. Instead of declaring individual variables, such as number0, number1, A specific element in an array is accessed by an index. All arrays consist of contiguous memory locations. The lowest address corresponds to the first element and the highest address to the last element.

This is called a single-dimensional array. The arraySize must be an integer constant greater than zero and type can be any valid C data type. If you omit the size of the array, an array just big enough to hold the initialization is created. You will create exactly the same array as you did in the previous example.

The above statement assigns the 5 th element in the array with a value of All arrays have 0 as the index of their first element which is also called the base index and the last index of an array will be total size of the array minus 1. An element is accessed by indexing the array name.

This is done by placing the index of the element within square brackets after the name of the array. The above statement will take the 10 th element from the array and assign the value to salary variable. The following example Shows how to use all the three above mentioned concepts viz. Arrays are important to C and should need a lot more attention.

C supports multidimensional arrays. The simplest form of the multidimensional array is the two-dimensional array. You can pass to the function a pointer to an array by specifying the array's name without an index. You can generate a pointer to the first element of an array by simply specifying the array name, without any index. Pointers in C are easy and fun to learn. Some C programming tasks are performed more easily with pointers, and other tasks, such as dynamic memory allocation, cannot be performed without using pointers.

So it becomes necessary to learn pointers to become a perfect C programmer. Let's start learning them in simple and easy steps. A pointer is a variable whose value is the address of another variable, i. Like any variable or constant, you must declare a pointer before using it to store any variable address.

Here, type is the pointer's base type; it must be a valid C data type and var-name is the name of the pointer variable. However, in this statement the asterisk is being used to designate a variable as a pointer.

The actual data type of the value of all pointers, whether integer, float, character, or otherwise, is the same, a long hexadecimal number that represents a memory address.

The only difference between pointers of different data types is the data type of the variable or constant that the pointer points to. There are a few important operations, which we will do with the help of pointers very frequently. It is always a good practice to assign a NULL value to a pointer variable in case you do not have an exact address to be assigned.

This is done at the time of variable declaration. A pointer that is assigned NULL is called a null pointer. The NULL pointer is a constant with a value of zero defined in several standard libraries. In most of the operating systems, programs are not permitted to access memory at address 0 because that memory is reserved by the operating system. However, the memory address 0 has special significance; it signals that the pointer is not intended to point to an accessible memory location.

But by convention, if a pointer contains the null zero value, it is assumed to point to nothing. Pointers have many but easy concepts and they are very important to C programming. Passing an argument by reference or by address enable the passed argument to be changed in the calling function by the called function. C allows a function to return a pointer to the local variable, static variable, and dynamically allocated memory as well.

Thus a null-terminated string contains the characters that comprise the string followed by a null. The following declaration and initialization create a string consisting of the word "Hello". To hold the null character at the end of the array, the size of the character array containing the string is one more than the number of characters in the word "Hello. Actually, you do not place the null character at the end of a string constant.

Arrays allow to define type of variables that can hold several data items of the same kind. Similarly structure is another user defined data type available in C that allows to combine data items of different kinds.

Structures are used to represent a record. Suppose you want to keep track of your books in a library. To define a structure, you must use the struct statement. The struct statement defines a new data type, with more than one member. The structure tag is optional and each member definition is a normal variable definition, such as int i; or float f; or any other valid variable definition.

At the end of the structure's definition, before the final semicolon, you can specify one or more structure variables but it is optional. To access any member of a structure, we use the member access operator. The member access operator is coded as a period between the structure variable name and the structure member that we wish to access. You would use the keyword struct to define variables of structure type. You can pass a structure as a function argument in the same way as you pass any other variable or pointer.

Now, you can store the address of a structure variable in the above defined pointer variable. Bit Fields allow the packing of data in a structure. Contents Exit focus mode. Is this page helpful? Please rate your experience Yes No. Any additional feedback? Submit and view feedback for This product This page. View all page feedback.