How To Create A "Template" Variable Inside A Class

Variables in C++

A variable is a name given to a retentivity location. It is the basic unit of storage in a program.

• The value stored in a variable can exist changed during programme execution.
• A variable is only a name given to a retentivity location, all the operations washed on the variable effects that retentiveness location.
• In C++, all the variables must be declared earlier utilize.

How to declare variables?

A typical variable declaration is of the form:

// Declaring a single variable type variable_name;  // Declaring multiple variables: blazon variable1_name, variable2_name, variable3_name;

A variable name can consist of alphabets (both upper and lower instance), numbers and the underscore '_' character. Nonetheless, the proper name must not showtime with a number.

In the above diagram,

datatype: Type of data that can be stored in this variable.
variable_name: Proper name given to the variable.
value: It is the initial value stored in the variable.

Examples:

// Declaring float variable float simpleInterest;   // Declaring integer variable int time, speed;   // Declaring grapheme variable char var;          

Difference between variable declaration and definition

The variable declaration refers to the part where a variable is beginning declared or introduced before its first use. A variable definition is a part where the variable is assigned a retentiveness location and a value. Nearly of the times, variable declaration and definition are washed together.
See the following C++ program for better clarification:

CPP

#include <iostream>

using namespace std;

int main()

{

char a123 = 'a' ;

float b;

int _c, _d45, due east;

cout << a123 << endl;

return 0;

}

Types of variables

There are three types of variables based on the scope of variables in C++:

• Local Variables
• Example Variables
• Static Variables

Let usa now acquire most each one of these variables in item.

1. Local Variables: A variable defined within a cake or method or constructor is called local variable.
   • These variable are created when the block in entered or the function is called and destroyed after exiting from the block or when the call returns from the function.
   • The scope of these variables exists only within the cake in which the variable is alleged. i.e. we can access these variable but within that block.
   • Initialisation of Local Variable is Mandatory.
2. Instance Variables: Example variables are not-static variables and are declared in a class exterior any method, constructor or block.
   • Equally case variables are declared in a grade, these variables are created when an object of the course is created and destroyed when the object is destroyed.
   • Dissimilar local variables, we may use access specifiers for instance variables. If nosotros practise not specify whatsoever access specifier then the default access specifier will be used.
   • Initialisation of Instance Variable is not Mandatory.
   • Instance Variable can be accessed simply by creating objects.
3. Static Variables: Static variables are also known as Class variables.
   • These variables are alleged similarly as instance variables, the difference is that static variables are alleged using the static keyword within a form outside whatever method constructor or block.
   • Different instance variables, we can only have one re-create of a static variable per class irrespective of how many objects nosotros create.
   • Static variables are created at the beginning of program execution and destroyed automatically when execution ends.
   • Initialization of Static Variable is non Mandatory. Its default value is 0
   • If nosotros admission the static variable similar Example variable (through an object), the compiler volition show the alarm bulletin and information technology won't halt the program. The compiler will replace the object name to form name automatically.
   • If we access the static variable without the grade name, Compiler will automatically append the form name.

Instance variable Vs Static variable

• Each object will take its ain copy of case variable whereas We can only accept 1 copy of a static variable per grade irrespective of how many objects we create.
• Changes made in an case variable using 1 object will not exist reflected in other objects as each object has its own copy of instance variable. In case of static, changes will be reflected in other objects every bit static variables are common to all object of a class.
• Nosotros can admission case variables through object references and Static Variables can be accessed directly using class proper noun.
• Syntax for static and instance variables:

  class Example {     static int a; // static variable     int b;        // instance variable }

How To Create A "Template" Variable Inside A Class,

Source: https://www.geeksforgeeks.org/variables-in-c/

Posted by: raleyjuste1960.blogspot.com

Share this post