declaration and assignment of variables in c

• Developer Help
• What's New

C Programming Variable Declarations and Definitions

In the C programming language, variables must be declared before they can be used. This tells the compiler how to work with the variable and tells the linker how much space needs to be allocated for it.

• Variable Declarations

To declare a variable, you need to provide its  type  and an  identifier  (name). The general form for declaring variables is:

type identifier 1 ,  identifier 2 , …  identifier n ;

This means you can declare one or more variables of the same type by starting with the type, followed by a comma-separated list of identifiers with a semicolon at the very end. Variables of the same type don't need to be declared together. You could also split them up into multiple declarations of a single variable, each on its own line. In fact, this is a more common practice as it makes it easier to add a comment after each variable to describe its purpose.

Here are a few examples of variable declarations:

• Variable Declarations with Definitions

Sometimes, you will want to ensure that a variable has an initial value for its first use. Conveniently, this can be done as part of the variable's declaration. The general form to both declare and define a variable in one step looks like this:

  type identifier 1  =  value 1 ,  identifier 2  =  value 2 , …  identifier n  =  value n ;

While initializing variables like this can be very convenient, there is a price to pay in terms of startup time. The  C Runtime Environment  startup code initializes these variables before your  main()  function is called. The initial values are stored along with the program code in the non-volatile flash memory. When the device powers on, the startup code will loop through all the initialized variables and copy their initial values from Flash into the variable's RAM location.

Here are a few examples showing the various ways variables can be declared alone or declared and defined together:

On This Page

Microchip support.

Query Microchip Forums and get your questions answered by our community:

    Microchip Forums   AVR Freaks Forums

If you need to work with Microchip Support staff directly, you can submit a technical support case. Keep in mind that many questions can be answered through our self-help resources, so this may not be your speediest option.

    Technical Support Portal

PrepBytes Blog

ONE-STOP RESOURCE FOR EVERYTHING RELATED TO CODING

Sign in to your account

Forgot your password?

Login via OTP

We will send you an one time password on your mobile number

An OTP has been sent to your mobile number please verify it below

Register with PrepBytes

What is variable in c and how to declare.

Last Updated on January 9, 2024 by Ankit Kochar

Understanding variables in C programming is fundamental as they serve as containers to store data within a program. Variables possess various data types and hold different values, playing a crucial role in manipulating and managing information in a program. This article aims to elucidate the concept of variables in C, explaining their declaration, types, and usage, providing a comprehensive guide for beginners and enthusiasts alike.

What is a Variable in C?

Variables in C are nothing but a name we give to a memory location that is used to store data or value. We can understand it as a container that stores the data. Variables in c can store different types of data like integers, characters, floating point numbers, strings, etc. We can use the variables in c to represent data or values that can be used throughout the program. The value of the variables in c can be changed or modified during the execution of the program.

Variable Declaration in C

In this section, we will see the variable definition in c. The general syntax of variable declaration in c.

The above syntax has three aspects.

• Variable declaration: This will tell the compiler about the existence of the variable. In this, we will define the data type of the variable here the variable does not been allocated with any memory.
• Variable Definition: Here we will name the variable that we want to use in the program. Variables in c will be allocated with some memory after variable definition. Initially, it will store the garbage value until it is initialized with any value.
• Variable Initialization: As the name suggests here the variables in c will get assigned some value.

Rules for Declaring Variables in C

There are certain rules that you need to follow while working with variables in c. Some of them are mentioned below:

• It is preferred to declare variables at the start of the block like functions, loops, etc.
• You have to use the underscore to separate words in variable names.
• All of the declaration statements must end with a semicolon.
• Use const for the variables that need not be modified.
• The variable name should not start with a number.
• The same name variables should not be declared in the same scope.
• It is advised to give meaningful names to the variables.
• It is preferred to declare all the variables belonging to the same data type in the same line.

Purpose of Variable Declaration in C

Variable declaration is a technique used in the C programming language to declare a variable and allot memory for it. Data that can be changed and accessed during program execution is stored in variables.

Before a variable is used in a program, it must be declared in C so that the compiler is aware of its name and data type. This ensures that the variable is used correctly in the program and aids the compiler in allocating memory space for the variable.

Types of Variables in C

We can classify variables on various basis like on the basis of scope, on the basis of a lifetime, on the basis of memory, etc.

Classifications in the basis of Scope

Variables in c are classified on the basis of scope. The scope can be referred as the region in which the variable is able to perform its operation, in simple words where the variable exists. Beyond the scope, we cannot access the variable as it is out of scope.

There are two types of variables in c on the basis of scope and they are:

• Local Variables
• Global Variables

Local Variable They are nothing but the variables that are declared within a block or a function of code. They cannot be accessed outside of the block in which they are assigned and their scope is limited to that block or function only.

Let’s understand this with the example

Explanation of the above example In the above example we have declared a local variable in the function sample with the name x and the function prints the variable hence the answer is 18, i.e. the value of the local variable declared.

Global Variable Unlike local variables they are declared outside the function or block hence they can be accessed from anywhere in the program hence their scope is the whole program.

Let’s understand this with the help of an example.

Explanation of the above example In the above example we have declared a global variable and have tried to access it in different functions and it gives the answer without any error.

Classifications on the Basis of Storage Class

Storage class can be understood as a concept that tells us to determine lifetime, scope, memory location, and the default value of the variables in c.

There are mainly 4 types of variables in c based on storage class.

• Static Variables
• Automatic Variables
• Extern Variables
• Register Variables

Static Variables These are the types of variables that are defined by static keywords. We can only define these types of variables only once and on the basis of the declaration, their scope can be local or global. Their default value is 0.

Syntax of Static Variable The syntax of static variable is given below:

Let’s understand static variables in c with the help of the example

Explanation of the above example As you can see in the above example the value of the local variable does not change with any function call but the value of the static variable is printed incremented every time.

Automatic Variables They are known as auto variables. All the local variables are automatic variables by default. Their lifetime is till the end of the bock and the scope is local. We can use the auto keyword to define an automatic variable and their default value is the garbage value.

Syntax of Automatic Variable Syntax of automatic variables is given below:

Now let’s look at the example of automatic variable

Explanation of the above example In the above example both the variables are automatic variables but the only difference is that y is declared explicitly.

External Variable These are the types of variables that can be shared between multiple files. We can use this variable to share the data between any file just have to include the file in which the external variable is declared.

Syntax of External Variable The syntax of the external variable is given below.

Explanation of the above example In the above example we have declared x as an external variable and can be used in multiple files.

Register Variable They are the variables in c which are stored in CPU registers rather than the RAM. They have the local scope and be only valid till the end of function or block.

Syntax of Register Variable

Code Implementation

Explanation of the above example In the above example we have declared an register variable and printed the value of that variable.

Constant Variable The constant variable differs from the rest of the above-mentioned variables as we can change the value of other variables any number of times but we cannot change the value of the constant variable once it is initialized. It is only a read-only variable. We can define it using a constant keyword.

Syntax of Constant Variable The syntax of the constant variable is given below.

Explanation of the above approach In the above approach we have declared a constant variable and when tried to change its value we got the above error.

Need of Variables in C

In the C programming language, variables are a fundamental component of any program. They are used to store data in the computer’s memory, allowing for the manipulation and reuse of values during runtime. Variables are essential for performing arithmetic, logical, and other manipulations on data stored in memory, and they enable you to dynamically allocate memory and pass values between functions. In C, variables are used to store a wide range of values such as numbers, characters, and strings, and they allow you to reuse values multiple times without having to type them out repeatedly. Variables are an essential tool in creating efficient and functional C programs and mastering their use is a crucial step toward becoming a proficient C programmer.

Conclusion In conclusion, mastering the concept of variables in C programming is pivotal for developing efficient and functional code. Through this article, you’ve learned about the significance of variables, their types, declaration methods, and how they facilitate data storage and manipulation in C. By practicing and experimenting with different variable types and declarations, you’ll enhance your proficiency in C programming and empower yourself to create robust and versatile applications.

Frequently Asked Questions Related to Variables in C

Here are some of the frequently asked questions about variables in c.

1. What happens if you declare a variable without initializing it in C? If a variable is declared without initialization in C, its value will be indeterminate and may contain garbage or unpredictable data until explicitly assigned a value.

2. How do you declare a variable in C? In C, you declare a variable by specifying its data type followed by the variable name. For example, int num; declares an integer variable named "num".

3. What are the basic data types for variables in C? C supports basic data types such as int, char, float, double, and void. These types vary in size and hold different kinds of data.

4. Can you change the value of a variable once it’s declared in C? Yes, you can change the value of a variable after it’s declared by assigning a new value using the assignment operator (=).

5. Are variable names case-sensitive in C? Yes, variable names in C are case-sensitive, meaning uppercase and lowercase letters are distinct.

6. What is the scope of a variable in C? The scope of a variable in C refers to the part of the program where the variable is accessible. Variables can have local scope within a function or global scope accessible throughout the program.

7. How do you initialize a variable during declaration in C? You can initialize a variable during declaration by assigning a value to it, for instance, int x = 10; initializes an integer variable "x" with the value 10.

8. Can a variable name start with a number in C? No, in C programming, a variable name cannot start with a number; it must begin with a letter or an underscore.

9. What is the difference between local and global variables in C? Local variables are declared within a function and can only be accessed within that function, while global variables are declared outside all functions and can be accessed by any function in the program.

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.

• Linked List
• Segment Tree
• Backtracking
• Dynamic Programming
• Greedy Algorithm
• Operating System
• Company Placement
• Interview Tips
• General Interview Questions
• Data Structure
• Other Topics
• Computational Geometry
• Game Theory

Related Post

Null character in c, assignment operator in c, ackermann function in c, median of two sorted arrays of different size in c, number is palindrome or not in c, implementation of queue using linked list in c.

• Declaration of Variables

Variables are the basic unit of storage in a programming language . These variables consist of a data type, the variable name, and the value to be assigned to the variable. Unless and until the variables are declared and initialized, they cannot be used in the program. Let us learn more about the Declaration and Initialization of Variables in this article below.

What is Declaration and Initialization?

• Declaration of a variable in a computer programming language is a statement used to specify the variable name and its data type. Declaration tells the compiler about the existence of an entity in the program and its location. When you declare a variable, you should also initialize it.
• Initialization is the process of assigning a value to the Variable. Every programming language has its own method of initializing the variable. If the value is not assigned to the Variable, then the process is only called a Declaration.

Basic Syntax

The basic form of declaring a variable is:

            type identifier [= value] [, identifier [= value]]…];

                                                OR

            data_type variable_name = value;

type = Data type of the variable

identifier = Variable name

value = Data to be stored in the variable (Optional field)

Note 1: The Data type and the Value used to store in the Variable must match.

Note 2: All declaration statements must end with a semi-colon (;)

Browse more Topics Under Data Types, Variables and Constants

• Concept of Data types
• Built-in Data Types
• Constants in Programing Language 
• Access Modifier
• Variables of Built-in-Datatypes
• Assignment Statement
• Type Modifier

Rules to Declare and Initialize Variables

There are few conventions needed to be followed while declaring and assigning values to the Variables –

• Variable names must begin with a letter, underscore, non-number character. Each language has its own conventions.
• Few programming languages like PHP, Python, Perl, etc. do not require to specify data type at the start.
• Always use the ‘=’ sign to initialize a value to the Variable.
• Do not use a comma with numbers.
• Once a data type is defined for the variable, then only that type of data can be stored in it. For example, if a variable is declared as Int, then it can only store integer values.
• A variable name once defined can only be used once in the program. You cannot define it again to store another type of value.
• If another value is assigned to the variable which already has a value assigned to it before, then the previous value will be overwritten by the new value.

Types of Initialization

Static initialization –.

In this method, the variable is assigned a value in advance. Here, the values are assigned in the declaration statement. Static Initialization is also known as Explicit Initialization.

Dynamic Initialization –

In this method, the variable is assigned a value at the run-time. The value is either assigned by the function in the program or by the user at the time of running the program. The value of these variables can be altered every time the program runs. Dynamic Initialization is also known as Implicit Initialization.

In C programming language –

In Java Programming Language –

FAQs on Declaration of Variables

Q1. Is the following statement a declaration or definition?

extern int i;

• Declaration

Answer – Option B

Q2. Which declaration is correct?

• int length;
• float double;
• float long;

Answer – Option A, double, long and int are all keywords used for declaration and keywords cannot be used for declaring a variable name.

Q3. Which statement is correct for a chained assignment?

• int x, y = 10;
• int x = y = 10;
• Both B and C

Answer – Option C

Customize your course in 30 seconds

Which class are you in.

Data Types, Variables and Constants

• Variables in Programming Language
• Concept of Data Types
• Type Modifiers
• Access Modifiers
• Constants in Programming Language

Leave a Reply Cancel reply

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

Download the App

• Trending Categories

• Selected Reading
• UPSC IAS Exams Notes
• Developer's Best Practices
• Questions and Answers
• Effective Resume Writing
• HR Interview Questions
• Computer Glossary

Explain variable declaration and rules of variables in C language

Let us first understand, what is a variable.

It is the name for memory location that may be used to store a data value.

A variable may take different values at different times during execution.

A variable name may be chosen by the programmer in a meaningful way, so as to reflect its function (or) nature in the program.

For example, sum, avg, total etc.

Rules for naming variable

The rules for naming a variable are explained below −

They must begin with a letter.

Maximum length of variable is 31 characters in ANSI standard. But, first eight characters are significant by many compilers.

Upper and lowercase characters are different. For example: total, TOTAL, Total are 3 different variables.

The variable is not to be a keyword.

White space is not allowed.

Variable declaration

The syntax and example with regards to variable declaration are explained below −

Given below is the syntax for variable declaration −

Where, v1, v2,...vn are names of variables.

For example,

Variable can be declared in two ways −

Local declaration − ‘Local declaration’ is declaring a variable inside the main block and its value is available within that block.

Global declaration − ‘Global declaration’ is declaring a variable outside the main block and its value is available throughout the program.

Following is the C program for local and global declaration of variables in C language −

Given below is a C program to find the selling price (SP) and cost price (CP) of an article −

 Live Demo

The output is as follows −

• Related Articles
• Explain the variable declaration, initialization and assignment in C language
• Rules For Variable Declaration in Java
• Explain scope of a variable in C language.
• Explain Lifetime of a variable in C language.
• Explain Binding of a variable in C language.
• Explain the accessing of structure variable in C language
• Structure declaration in C language
• Explain scope rules related to the functions in C language
• Explain the scope rules related to the statement blocks in C language
• What are the local and global scope rules in C language?
• Java variable declaration best practices
• What are the rules to declare variables in C++?
• Java variable naming rules
• What are the basic rules for defining variables in C++?
• Explain the characteristics and operations of arrays in C language

Kickstart Your Career

Get certified by completing the course

1.4 — Variable assignment and initialization

There are 6 basic ways to initialize variables in C++:

Much like copy assignment, this copies the value on the right-hand side of the equals into the variable being created on the left-hand side. In the above snippet, variable width will be initialized with value 5 .

Differences Between Definition, Declaration, and Initialization

Last updated: March 18, 2024

• Programming
• Compilers and Linkers

It's finally here:

>> The Road to Membership and Baeldung Pro .

Going into ads, no-ads reading , and bit about how Baeldung works if you're curious :)

1. Introduction

In this tutorial, we’ll explain the differences between definition, declaration, and initialization in computer programming.

The distinction between the three concepts isn’t clear in all languages. It depends on the language we’re coding in and the thing we want to declare, define or initialize.

2. Declarations

A declaration introduces a new identifier into a program’s namespace. The identifier can refer to a variable, a function, a type , a class, or any other construct the language at hand allows.

For a statement to be a declaration, it only needs to tell us what the declared identifier is. After reading a declaration statement, the code processor ( compiler or interpreter ) can differentiate between legal and illegal uses of the identifier.

For example, in C, we can declare a function by specifying its signature or a variable by specifying its type:

We see that g is a function with an integer argument and no return value. Similarly, x is an integer variable. That’s everything a compiler needs to know about g and x to report incorrect use. For instance, x(g) would raise a compiler error, whereas g(x) wouldn’t.

Other languages work the same. Their syntax rules may differ, but none allows us to use an identifier before declaring it.

2.1. Formal Languages

2.2. what declarations can’t do.

A declaration tells us what an identifier is. That isn’t enough.

Let’s go back to the above example. We can say that our C compiler wouldn’t complain about statements such as g(5) . However, g doesn’t have a body specifying the operations it applies to its argument. As a result, we can’t execute any statement involving g , so we’ll get a runtime error if we try.

In other words, declaring an identifier doesn’t guarantee its existence during the runtime. It’s our job to make sure that’s the case by defining it.

3. Definitions

When defining an identifier, we instruct the code processor to allocate , i.e., reserve a sufficiently large memory chunk for it. That means and requires different things depending on the identifier’s type.

For example, to define a function, we need to write its body. When handling the function’s definition, the processor converts it into machine code , places it in the reserved space, and links the function’s name to the place in memory containing the code. Without the body, the processor can’t know how much space to reserve.

To define a class in an object-oriented language , we implement its methods and specify its attributes. Similar goes for any type in any language.

To define a variable in a statically typed language , we need to specify its type explicitly. However, that’s the same as declaring it. So, a statement can both declare and define an identifier in some cases.

For instance, int x from the above example creates an identifier named x , reserves the space for an integer in the memory, and links the identifier to it:

Consequently, the linker knows where to find the value of x . But that doesn’t mean the variable will have any value when we try to use it. Further, how do we define variables in dynamically typed languages?

We solve those issues with initialization.

4. Initialization

To initialize a variable, we assign it its starting value. That way, we make sure the expressions using the variable won’t throw a runtime error.

In a statically typed language, initialization and definition can be separate steps but can happen at the same time. For example:

In dynamically typed languages, we define a variable by initializing it since there are no explicit type declarations:

Further, depending on the language rules or the code processor, each type can have a default value . That means that every variable in such a statically typed language will get its type’s default value when we define it. If that’s the case, initialization is implicit.

5. Conclusion

In this article, we talked about declarations, definitions, and initialization. They mean different things but sometimes overlap in code.

Declaration of Variables in C

In any programming language, We can refer to anything with the help of variables. They are the most essential part, from writing a normal program to writing advanced software. Variable allows us to access the particular element and assign them with some value. With great powers comes great responsibilities, So variables are bounded by some declaration and assignment rules which we will look into.

Introduction to Variable Declaration in C

Variables are the most essential part of any programming language.

Let's say we need to calculate the area of a rectangle. To make this arithmetic calculation, we need to store the length and width of the rectangle. To store the length and width of the rectangle, we need to allocate some space in a memory location for the data, and the name given to that memory location is called Variable .

For each different data, we give different variable names to it for later use in the program.

For better understanding, let's look at the following image. It shows the memory location where the data is stored with a variable name as myvar and value 22 to it.

a) General syntax for declaring a variable

In variable declarations, we can declare variables in two ways:

• Declaration of variable without initializing any value to it

data_type variable_name;

Eg:- char Final_Grade; // Final_Grade is a variable of type char, and no value is assigned to it.

• Declaration of variable with initializing some value to it

data_type variable_name = val;

Eg:- int age = 22; // age is a variable of type int and holds the value 22 .

Here, data_type specifies the type of variable like int, char, etc.

variable_name specifies the name of the variable. val is the value for which we are initializing the variable.

Program to Illustrate the Declaration of Variables in C

To use some data in the program, we need to declare a variable with the corresponding data type and assign some value to it. And then use that variable name to access the data.

While declaring a variable, memory space is not allocated to it. It happens only on initializing the variable.

• So what happens when we declare a variable without initializing it? When we declare a variable without initializing it, then it just stores some garbage value or zero value. But if we assign some value to it, then it will be overwritten with the new value.

Let's see an example to understand the above concept.

From the above program, we can see that the initial value of c is 0. And when we reassign the new value to C variable, it will be overwritten with the new value.

Types of Declaration of Variables in C

Variables in C need to be declared by storing any data type and any variable name before using it.

There are two types of declaration of variables in C:

• Primary Type Declaration
• User-Defined Type Declaration

a) Primary Type Declaration

Primary type declaration is used to declare a variable with primitive data types, which are also called as built-in data types.

Most commonly used primary data types are int, float, char, boolean, double, long etc.

• Single primary type declaration

Eg:- char Grade = 'A';

Multiple primary type declarations in the same line

When multiple variables are declared in the same line, we need to use a comma to separate the variables, as shown below.

Eg:- int Length= 12, Width = 13, Depth = 14;

• Multiple primary type declaration in different lines When multiple variables are declared in different lines, we need to use semi-colons to separate the variables, as shown below.

b) User-Defined Type Declaration

User-Defined Type Declaration is a type of declaration where the data type is defined by the user.

Some of the most commonly used data types are struct, Union, enum, typedef etc.

Structure Structures are used to group data items of different types into a single user-defined data type.

Union Unions are user-defined data types in which members share a common memory location, so any one of them is accessible at a time. When we want to access only one member, then we use Union.

Typedef We need to use the keyword typedef to define the data type. Now we can use those new data types in our program, as shown below.

For example,

Here, we have defined a new data type called person_name, person_age and salary. Now we can use these data types to declare variables as follows.

Here, Akhil, Bhanu, and Chaitanya are declared as char type variables and 2 2 22 2 2 , 2 3 23 2 3 , 2 4 24 2 4 are declared as int type variables and 2 2 . 2 2 22.22 2 2 . 2 2 , 2 3 . 2 3 23.23 2 3 . 2 3 , 2 4 . 2 4 24.24 2 4 . 2 4 are declared as float type variables.

By using user-defined data types, we can create our own data types. For example, we can create a new data type called person_info which can store the name, age and salary of a person. And also increases the readability of the program.

The main difference between primary type declaration and user-defined type declaration is that in the primary type declaration, we can use any variable name for any data type. But in the user-defined type declaration, we can use any identifier for any data type.

Why do We Need to Declare a Variable in C?

Basically, we need to declare a variable to store various types of data in the program. So to perform some operations or tasks with the data, we need to store them in the computer's memory location. But we can't remember the address of the memory location where the data is stored. So to access the data, we name the memory location with a variable name and size depending on the data type.

In the program, by declaring a variable, we have to tell the compiler the type of data and the variable name to access the data.

Purpose of Variable Declarations

The main purpose of variable declaration is to store the required data in the memory location in the form of variables so that we can use them in our program to perform any operation or task.

By declaring a variable, we can use that variable in our program by using the variable name and its respective data type.

Let's take an example to understand this concept.

For example, We need to calculate the total marks of a student in all the subjects. So to calculate the total marks, we need to give the individual marks of each subject to the computer so that it will add them up. To use the data, we name the memory location with variable names and assign the value to the variable. So, we can use the variable name to access the data.

Rules to Declare Variable in C

In C language, we need to declare a variable with suitable data type and variable name.

Here are some of the rules we need to follow while declaring a variable in C:

• Variables should not be declared with the same name in the same scope.
• A variable name can start with anything like the alphabet and underscore. But the variable name should not start with a number.
• A variable name must not be a reserved keyword in C. For example, if you declare a variable name as label, int, float, char, function, else etc., then it will not be able to be used as a variable name.
• A variable name can contain any combination of alphabets, numbers and underscores.
• All the declaration statements must end with a semi-colon. (;)
• It is suggested to declare the variables of same data type in the same line.
• It will be better if we declare variable names with some meaningful names and then it clearly describes the purpose of the variable.

In the above-shown example, we declared variable names with Person_name , age, and weight instead of a, b, c etc., so that we can easily understand that variable name is used to store the age of a person.

• We can declare the variable either along with the initialization or without initializing it. If we do not initialize the variable, then it will take in the garbage value.
• In Primary Type, we use built-in data types such as int, float, char, boolean, double, long etc. and in User Defined Type, we use user-defined data types such as struct, Union, enum, typedef etc.
• The basic variable functionality provided by the C language is intuitive and straightforward. Still, quite a few details can help you make an embedded application more reliable and efficient.

• C Data Types
• C Operators
• C Input and Output
• C Control Flow
• C Functions
• C Preprocessors
• C File Handling
• C Cheatsheet
• C Interview Questions

C Variables

A variable in C language is the name associated with some memory location to store data of different types. There are many types of variables in C depending on the scope, storage class, lifetime, type of data they store, etc. A variable is the basic building block of a C program that can be used in expressions as a substitute in place of the value it stores.

What is a variable in C?

A variable in C is a memory location with some name that helps store some form of data and retrieves it when required. We can store different types of data in the variable and reuse the same variable for storing some other data any number of times.

They can be viewed as the names given to the memory location so that we can refer to it without having to memorize the memory address. The size of the variable depends upon the data type it stores.

C Variable Syntax

The syntax to declare a variable in C specifies the name and the type of the variable.

• data_type: Type of data that a variable can store.
• variable_name: Name of the variable given by the user.
• value: value assigned to the variable by the user.

Note: C is a strongly typed language so all the variables types must be specified before using them.

Variable Syntax Breakdown

There are 3 aspects of defining a variable:

• Variable Declaration
• Variable Definition
• Variable Initialization

1. C Variable Declaration

Variable declaration in C tells the compiler about the existence of the variable with the given name and data type.When the variable is declared, an entry in symbol table is created and memory will be allocated at the time of initialization of the variable.

2. C Variable Definition

In the definition of a C variable, the compiler allocates some memory and some value to it. A defined variable will contain some random garbage value till it is not initialized.

Note: Most of the modern C compilers declare and define the variable in single step. Although we can declare a variable in C by using extern keyword, it is not required in most of the cases. To know more about variable declaration and definition, click here.

3. C Variable Initialization

Initialization of a variable is the process where the user assigns some meaningful value to the variable when creating the variable.

Difference between Variable Initialization and Assignment

Initialization occurs when a variable is first declared and assigned an initial value. This usually happens during the declaration of the variable. On the other hand, assignment involves setting or updating the value of an already declared variable, and this can happen multiple times after the initial initialization.

How to use variables in C?

The below example demonstrates how we can use variables in C language.

Rules for Naming Variables in C

You can assign any name to the variable as long as it follows the following rules:

• A variable name must only contain alphabets, digits, and underscore.
• A variable name must start with an alphabet or an underscore only. It cannot start with a digit.
• No white space is allowed within the variable name.
• A variable name must not be any reserved word or keyword.

C Variable Types

The C variables can be classified into the following types:

• Local Variables
• Global Variables
• Static Variables
• Automatic Variables
• Extern Variables
• Register Variables

1. Local Variables in C

A Local variable in C is a variable that is declared inside a function or a block of code. Its scope is limited to the block or function in which it is declared.

Example of Local Variable in C

In the above code, x can be used only in the scope of function(). Using it in the main function will give an error.

2. Global Variables in C

A Global variable in C is a variable that is declared outside the function or a block of code. Its scope is the whole program i.e. we can access the global variable anywhere in the C program after it is declared.

Example of Global Variable in C

In the above code, both functions can use the global variable as global variables are accessible by all the functions.

Note: When we have same name for local and global variable, local variable will be given preference over the global variable by the compiler. For accessing global variable in this case, we can use the method mention here.

3. Static Variables in C

A static variable in C is a variable that is defined using the static keyword. It can be defined only once in a C program and its scope depends upon the region where it is declared (can be global or local ).

The default value of static variables is zero.

Syntax of Static Variable in C

As its lifetime is till the end of the program, it can retain its value for multiple function calls as shown in the example.

Example of Static Variable in C

In the above example, we can see that the local variable will always print the same value whenever the function will be called whereas the static variable will print the incremented value in each function call.

Note: Storage Classes in C is the concept that helps us to determine the scope, lifetime, memory location, and default value (initial value) of a variable.

4. Automatic Variable in C

All the local variables are automatic variables by default . They are also known as auto variables.

Their scope is local and their lifetime is till the end of the block. If we need, we can use the auto keyword to define the auto variables.

The default value of the auto variables is a garbage value.

Syntax of Auto Variable in C

Example of auto variable in c.

In the above example, both x and y are automatic variables. The only difference is that variable y is explicitly declared with the auto keyword.

5. External Variables in C

External variables in C can be shared between multiple C files . We can declare an external variable using the extern keyword.

Their scope is global and they exist between multiple C files.

Syntax of Extern Variables in C

Example of extern variable in c.

In the above example, x is an external variable that is used in multiple C files.

6. Register Variables in C

Register variables in C are those variables that are stored in the CPU register instead of the conventional storage place like RAM. Their scope is local and exists till the end of the block or a function.

These variables are declared using the register keyword.

The default value of register variables is a garbage value .

Syntax of Register Variables in C

Example of register variables in c.

NOTE: We cannot get the address of the register variable using addressof (&) operator because they are stored in the CPU register. The compiler will throw an error if we try to get the address of register variable.

Constant Variable in C

Till now we have only seen the variables whose values can be modified any number of times. But C language also provides us a way to make the value of a variable immutable. We can do that by defining the variable as constant.

A constant variable in C is a read-only variable whose value cannot be modified once it is defined. We can declare a constant variable using the const keyword.

Syntax of Const Variable in C

Note: We have to always initialize the const variable at the definition as we cannot modify its value after defining.

Example of Const Variable in C

FAQs on C Variables

Q1. what is the difference between variable declaration and definition in c.

In variable declaration, only the name and type of the variable is specified but no memory is allocated to the variable. In variable definition, the memory is also allocated to the declared variable.

Q2. What is the variable’s scope?

The scope of a variable is the region in which the variable exists and it is valid to perform operations on it. Beyond the scope of the variable, we cannot access it and it is said to be out of scope.

Please Login to comment...

Similar reads.

• C-Variable Declaration and Scope
• Best 10 IPTV Service Providers in Germany
• Python 3.13 Releases | Enhanced REPL for Developers
• IPTV Anbieter in Deutschland - Top IPTV Anbieter Abonnements
• Best SSL Certificate Providers in 2024 (Free & Paid)
• Content Improvement League 2024: From Good To A Great Article

Improve your Coding Skills with Practice

What kind of Experience do you want to share?

Search anything:

Definition vs Declaration vs Initialization in C/ C++

C++ c programming software engineering.

Open-Source Internship opportunity by OpenGenus for programmers. Apply now.

In this article, we have covered the differences between 3 core terms Definition, Declaration and Initialization in C and C++ along with code snippets.

Table of contents:

• Declaration
• Initialization

Conclusion / Table of Differences

To understand the difference between the two we should first understand each term independently.So,here we go.

1. Declaration

Declaration of a variable is generally a introduction to a new memory allocated to something that we may call with some name.

Properties of declaration - 1.Memory creation occurs at the time of declaration itself. 2.Variables may have garbage values. 3.Variables cannot be used before declaration.

2. Definition

In declaration, user defines the previously declared variable.

3. Initialisation

Initialisation is nothing but assigning the value at the time of declaration.

From the above explanation we can conclude the following-

• Declaration is just naming the variable.
• Definition does not means declaration '+' Initialisation as definition might be without initialisation.
• Initialisation is assigning valueto the declared variable. (At the time of declaration)

With this article at OpenGenus, you must have the complete idea of Definition vs Declaration vs Initialization in C/ C++.

Stack Exchange Network

Stack Exchange network consists of 183 Q&A communities including Stack Overflow , the largest, most trusted online community for developers to learn, share their knowledge, and build their careers.

Q&A for work

Connect and share knowledge within a single location that is structured and easy to search.

Variable declaration versus assignment syntax

Working on a statically typed language with type inference and streamlined syntax, and need to make final decision about syntax for variable declaration versus assignment. Specifically I'm trying to choose between:

Creating functions will use = regardless:

And assignment to compound objects will do likewise:

Which of options 1 or 2 would people find most convenient/least surprising/otherwise best?

• language-design
• language-features

• 1 Why do you need differentiate between the two? Edit: To clarify, why can't you make foo = ... always introduce or assign to a local, with syntax to exempt one name from the "introducing" part, instead making = alter a global/closed over variable (i.e. , like Python's global and nonlocal , possibly unified into one concept)? –  user7043 Commented Oct 27, 2013 at 20:09
• If by type inference you mean implicit declaration of variables, may I refer you to the ALGOL committee's remarks? They roundly boxed Tony Hoare's ears when he suggested adding FORTRAN-style implicit declaration to ALGOL. This was before the (possibly apocryphal) story of a lost interplanetary probe from a typographical error combined with implicit declaration, that converted a FORTRAN DO-statement into a legal assignment statement. –  John R. Strohm Commented Oct 28, 2013 at 3:31

3 Answers 3

There are many more aspects one should consider when settling for assignment/declaration syntax, than simple = vs. := bikeshedding.

Type inference or not, you will want a syntax for explicit type annotations. In some type systems, inference may not be possible without occasional explicit annotations. There two possible classes of syntax for this:

• A type-variable statement without further operators implies a declaration, e.g. int i in C . Some languages use postfix types like i int , ( Golang to a certain degree).
• There is a typing operator, often : or :: . Sometimes, this declares the type of a name: let i : int = 42 (e.g. Ocaml ). In an interesting spin of this, Julia allows a programmer to use type assertions for arbitrary expressions, along the lines of sum = (a + b):int .

You may also want to consider an explicit declaration keyword, like var , val or let . The advantage is not primarily that they make parsing and understanding of the code much easier, but that they unambiguously introduce a variable. Why is this important?

If you have closures, you need to precisely declare which scope a variable belongs to. Imagine a language without a declaration keyword, and implicit declaration through assignment (e.g. PHP or Python ). Both of these are syntactically challenged with respect to closures, because they either ascribe a variable to the outermost or innermost possible scope. Consider this Python:

Compare with a language that allows explicit declaration:

Explicit declarations allow variable shadowing. While generally a bad practice, it sometimes makes code much easier to follow – no reason to disallow it.

Explicit declarations offer a form of typo detection, because unbound variables are not implicitly declared. Consider:

You should also consider whether you would like to (optionally) enforce single-assignment form, e.g through keywords like val ( Scala ), let , or const or by default. In my experience, such code is easier to reason about.

How would a short declaration e.g. via := fare in these points?

• Assuming you have typing via a : operator and assigment via = , then i : int = 42 could declare a variable, the syntax i : = 42 would invoke inference of the variable, and i := 42 would be a nice contraction, but not an operator in itself. This avoids problems later on.
• Another rationale is the mathematical syntax for the declaration of new names x := expression or expression =: x . However, this has no significant difference to the = relation, except that the colon draws attention to one name. Simply using the := for similarity to maths is silly (considering the = abuse), as is using it for similarity to Pascal .

We can declare some more or less sane characteristics for := , like:

• It declares a new variable in the current scope
• which is re-assignable,
• and performs type inference.
• Re-declaring a variable in the same scope is a compilation error.
• Shadowing is permitted.

But in practice, things get murky. What happens when you have multiple assignments (which you should seriously consider), like

Should this throw an error because x is already declared in this scope? Or should it just assign x and declare y ? Go takes the second route, with the result that typo detection is weakened:

Note that the “RHS of typing-operator is optional” idea from above would disambiguate this, as every new variable would have to be followed by a colon:

Should = be declaration but := be assignment? Hell no. First, no language I know of does this. Second, when you don't use single-assignment form, then assignment is more common than declaration. Huffman-coding of operator requires that the shorter operator is used for the more common operation. But if you don't generally allow reassignment, the = is somewhat free to use (depending on whether you use = or == as comparison operator, and whether you could disambiguate a = from context).

• If assignment and declaration use the same operator, bad things happen: Closures, variable shadowing, and typo detection all get ugly with implicit declarations.
• But if you don't have re-assignments, things clear up again.
• Don't forget that explicit types and variable declarations are somewhat related. Combining their syntax has served many languages well.
• Are you sure you want such little visual distinction between assignment and declaration?

Personal opinion

I am fond of declaration keywords like val or my . They stand out, making code easier to grok. Explicit declarations are always a good idea for a serious language.

• Yeah, I'm using : for optional explicit type, so as you say, i := 42 is shorthand for i: int = 42 . I am allowing reassignment by default (so there needs to be some distinction), but it can be disabled with a final modifier as in Java. And I'm not a huge fan of declaring multiple variables on one line so I'm okay with losing that. –  rwallace Commented Oct 28, 2013 at 21:07

Both alternatives are bad. The first because it is far from obvious that a := operator creates a local variable, and the second because it means you have two different meanings for the = operator. Learn Dennis Ritchie's lesson, and don't have two operators that appear to be assignments, one of which is not.

• 2 Further, if I see := , I assume pascal assignment. That also means I expect = to test equality, not declare a variable. –  Telastyn Commented Oct 27, 2013 at 21:23
• 1 Trying to read a source code without understanding its notation is bad habit. And your "obvious" point won't work when you know the notation. Otherwise := and = are visually distinguishable very well. –  lorus Commented Oct 28, 2013 at 6:48
• 1 @lorus Tell that to every seasoned C programmer who's typed if (a = b) ... . It's not just a rookie mistake, everyone does it once in a while. In other words, it's a language design flaw. –  Ross Patterson Commented Oct 28, 2013 at 9:49
• 4 This problem with C syntax is that assignment is an expression. If it would be a statement, the problem won't occur. –  lorus Commented Oct 29, 2013 at 4:35

New variables should be declared with x := 5 and should be updated/reassigned with x = 5 . Kind of the norm now, eight years later. Mostly thanks to golang I think.

Your Answer

Reminder: Answers generated by artificial intelligence tools are not allowed on Software Engineering Stack Exchange. Learn more

Sign up or log in

Post as a guest.

Required, but never shown

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy .

Not the answer you're looking for? Browse other questions tagged language-design syntax language-features or ask your own question .

• The Overflow Blog
• Where does Postgres fit in a world of GenAI and vector databases?
• Featured on Meta
• We've made changes to our Terms of Service & Privacy Policy - July 2024
• Bringing clarity to status tag usage on meta sites

Hot Network Questions

• Should I report a review I suspect to be AI-generated?
• Cramer's Rule when the determinant of coefficient matrix is zero?
• A very interesting food chain
• Passport Carry in Taiwan
• Can a 2-sphere be squashed flat?
• Chess.com AI says I lost opportunity to win queen but I can't see how
• Walk or Drive to school?
• Do metal objects attract lightning?
• How much missing data is too much (part 2)? statistical power, effective sample size
• Parody of Fables About Authenticity
• Why was this lighting fixture smoking? What do I do about it?
• Is this a new result about hexagon?
• How do I make a command that makes a comma-separated list where all the items are bold?
• Is it advisable to contact faculty members at U.S. universities prior to submitting a PhD application?
• The size of elementary particles
• My visit is for two weeks but my host bought insurance for two months is it okay
• Reusing own code at work without losing licence
• Can I use a JFET if its drain current exceeds the Saturation Drain Current from the datasheet (or is my JFET faulty)?
• Do the amplitude and frequency of gravitational waves emitted by binary stars change as the stars get closer together?
• What happens if all nine Supreme Justices recuse themselves?
• Who was the "Dutch author", "Bumstone Bumstone"?
• What to call a test that consists of running a program with only logging?
• Why is PUT Request not allowed by default in OWASP CoreRuleSet
• Is it possible to have a planet that's gaslike in some areas and rocky in others?

C Functions

C structures, c reference, c declare multiple variables, declare multiple variables.

To declare more than one variable of the same type, use a comma-separated list:

You can also assign the same value to multiple variables of the same type:

C Exercises

Test yourself with exercises.

Fill in the missing parts to create three variables of the same type, using a comma-separated list :

Start the Exercise

COLOR PICKER

Contact Sales

If you want to use W3Schools services as an educational institution, team or enterprise, send us an e-mail: [email protected]

Report Error

If you want to report an error, or if you want to make a suggestion, send us an e-mail: [email protected]

Top Tutorials

Top references, top examples, get certified.

• Stack Overflow for Teams Where developers & technologists share private knowledge with coworkers
• Advertising & Talent Reach devs & technologists worldwide about your product, service or employer brand
• OverflowAI GenAI features for Teams
• OverflowAPI Train & fine-tune LLMs
• Labs The future of collective knowledge sharing
• About the company Visit the blog

Collectives™ on Stack Overflow

Find centralized, trusted content and collaborate around the technologies you use most.

Q&A for work

Connect and share knowledge within a single location that is structured and easy to search.

Get early access and see previews of new features.

How to correctly declare/assign values for variables in c++

Should I declare variables at the top of my c++ program before assigning values:

Or alternatively is it correct/acceptable to assign values to variables the following way:

I am new to c++ and I would like to know which way is accepted by the c++ community.

• declaration

• Both will work. The latter is better style because it's clear at a glance that the variables are initialized. –  interjay Commented Jan 5, 2020 at 14:31
• Either is fine, though the second is probably better when possible because it guarantees a value in each variable and avoids any undefined behavior from reading an uninitialized variable. –  user10957435 Commented Jan 5, 2020 at 14:32
• 4 They're not equivalent operations. One is initialization, the other assignment. The use case for each is obvious. Use initialization via construction (the second snippet) when initial values are known at variable declaration time; use assignment (the first snippet) when that is not the case. That's seriously it. –  WhozCraig Commented Jan 5, 2020 at 14:32
• you question is in C++, it's not C at all. There is no thing like C/C++ –  Van Tr Commented Jan 5, 2020 at 14:41
• The answers are really good. I suggest you check this out 'rules of three in C++' because you're new. That way you can understand better. –  shalom Commented Jan 5, 2020 at 14:44

2 Answers 2

Second way is more idiomatic C++ and should be preferred. See also core guideline NR.1 :

Reason The “all declarations on top” rule is a legacy of old programming languages that didn’t allow initialization of variables and constants after a statement. This leads to longer programs and more errors caused by uninitialized and wrongly initialized variables.

It is also more efficient because the first is a default-construction followed by assignment, and the second one is simply construction.

When you know the initial value beforehand, the second way is more efficient because you only invoke a constructor, while in the first you first invoke default constructor and then an assignment operator.

Your Answer

Reminder: Answers generated by artificial intelligence tools are not allowed on Stack Overflow. Learn more

Sign up or log in

Post as a guest.

Required, but never shown

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy .

Not the answer you're looking for? Browse other questions tagged c++ variables declaration or ask your own question .

• The Overflow Blog
• Where does Postgres fit in a world of GenAI and vector databases?
• Featured on Meta
• We've made changes to our Terms of Service & Privacy Policy - July 2024
• Bringing clarity to status tag usage on meta sites
• What does a new user need in a homepage experience on Stack Overflow?
• Feedback requested: How do you use tag hover descriptions for curating and do...
• Staging Ground Reviewer Motivation

Hot Network Questions

• Is it possible to have a planet that's gaslike in some areas and rocky in others?
• How can judicial independence be jeopardised by politicians' criticism?
• What is an intuitive way to rename a column in a Dataset?
• Who was the "Dutch author", "Bumstone Bumstone"?
• How much missing data is too much (part 2)? statistical power, effective sample size
• Relation between stopping times and their filtrations
• Are quantum states like the W, Bell, GHZ, and Dicke state actually used in quantum computing research?
• Two way ANOVA or two way repeat measurement ANOVA
• Using conditionals within \tl_put_right from latex3 explsyntax
• Using "no" at the end of a statement instead of "isn't it"?
• Is it advisable to contact faculty members at U.S. universities prior to submitting a PhD application?
• Why was this lighting fixture smoking? What do I do about it?
• Why is PUT Request not allowed by default in OWASP CoreRuleSet
• Are carbon fiber parts riveted, screwed or bolted?
• How does the summoned monster know who is my enemy?
• Walk or Drive to school?
• If inflation/cost of living is such a complex difficult problem, then why has the price of drugs been absoultly perfectly stable my whole life?
• I'm trying to remember a novel about an asteroid threatening to destroy the earth. I remember seeing the phrase "SHIVA IS COMING" on the cover
• Purpose of burn permit?
• Does Vexing Bauble counter taxed 0 mana spells?
• Worth replacing greenboard for shower wall
• Reusing own code at work without losing licence
• Completely introduce your friends
• Why doesn't the world fill with time travelers?