Variables and strings

By: Unknown on 00:50

Initialization of variables

At the point when the variables in the case above are pronounced, they have an undetermined quality until they are doled out a worth to many people's surprise. Be that as it may it is feasible for a variable to have a particular worth from the minute it is pronounced. This is known as the introduction of the variable.

In C++, there are three approaches to introduce variables. They are all identical and are reminiscent of the development of the dialect throughout the years:

The first one, known as c-like initialization (because it is inherited from the C language), consists of appending an equal sign followed by the value to which the variable is initialized:

type identifier = initial_value;
For example, to declare a variable of type int called x and initialize it to a value of zero from the same moment it is declared, we can write:

int x = 0;

A second method, known as constructor initialization (introduced by the C++ language), encloses the initial value between parentheses (()):

type identifier (initial_value);
For example:

int x (0);

Finally, a third method, known as uniform initialization, similar to the above, but using curly braces ({}) instead of parentheses (this was introduced by the revision of the C++ standard, in 2011):

type identifier {initial_value};
For example:

int x {0};

All three ways of initializing variables are valid and equivalent in C++.

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18

// initialization of variables #include <iostream> using namespace std; int main () { int a=5; // initial value: 5 int b(3); // initial value: 3 int c{2}; // initial value: 2 int result; // initial value undetermined a = a + b; result = a - c; cout << result; return 0; }

6

 

Introduction to strings

Major sorts speak to the most essential sorts took care of by the machines where the code may run. Anyway one of the real qualities of the C++ dialect is its rich situated of compound sorts, of which the key sorts are simple building squares.

An illustration of compound sort is the string class. Variables of this sort can store successions of characters, for example, words or sentences. An exceptionally suitable characteristic!

A first difference with fundamental data types is that in order to declare and use objects (variables) of this type, the program needs to include the header where the type is defined within the standard library (header <string>):

1 2 3 4 5 6 7 8 9 10 11 12

// my first string #include <iostream> #include <string> using namespace std; int main () { string mystring; mystring = "This is a string"; cout << mystring; return 0; }

This is a string

As you can see in the previous example, strings can be initialized with any valid string literal, just like numerical type variables can be initialized to any valid numerical literal. As with fundamental types, all initialization formats are valid with strings:

1 2 3

string mystring = "This is a string"; string mystring ("This is a string"); string mystring {"This is a string"};

Strings can also perform all the other basic operations that fundamental data types can, like being declared without an initial value and change its value during execution:

1 2 3 4 5 6 7 8 9 10 11 12 13 14

// my first string #include <iostream> #include <string> using namespace std; int main () { string mystring; mystring = "This is the initial string content"; cout << mystring << endl; mystring = "This is a different string content"; cout << mystring << endl; return 0; }

This is the initial string content This is a different string content

Note: inserting the endl manipulator ends the line (printing a newline character and flushing the stream).
The string class is a compound type. As you can see in the example above, compound types are used in the same way as fundamental types: the same syntax is used to declare variables and to initialize them.
                                                                 

"News powered by"