C++ Array

Concept of array systems in C++.

* An array is a one of the data structure in C++, that can store a fixed size sequential collection of elements of same data type.

Array

In C++, an array is a collection of elements of the same data type, stored in contiguous memory locations. The size of the array is determined at the time of declaration and cannot be changed during runtime. Here are some basic steps to declare, initialize, and use an array in C++:

1. Declaration:

You declare an array by specifying its data type, followed by the array name and the size of the array in square brackets. For example:

int myArray[5];

* Declares an integer array with a size of 5

2. Initialization:

You can initialize an array at the time of declaration or later using braces '{}' with a comma-separated list of values:

int myArray[5] = {1, 2, 3, 4, 5};

* Initializes an array with values

3. Accessing Elements:

Array elements are accessed using their index. The index starts at 0 for the first element and goes up to 'size - 1'. For example:

int value = myArray[2];

* Accesses the third element of the array

Array Example:

Here's a simple example that declares, initializes, and accesses elements in a C++ array:

cpp Copy Code
#include<iostream>

int main() {
    int myArray[5] = {1, 2, 3, 4, 5};

    // Accessing and printing elements of the array
    for (int i = 0; i < 5; ++i) {
        std::cout << "Element at index " << i << ": " << myArray[i] << std::endl;
    }

    return 0;
}
Output:
Element at index 0: 1
Element at index 1: 2
Element at index 2: 3
Element at index 3: 4
Element at index 4: 5

* In this example, the array myArray is declared, initialized, and then elements are accessed and printed using a loop.

Null Character

strings are typically represented as arrays of characters, terminated by a special character known as the null character. The null character is represented by the escape sequence '\0' and has a numeric value of 0.

When working with character arrays (C-strings), the null character is used to indicate the end of the string. This allows functions that operate on strings to determine where the string ends in memory. Here's an example:

int main() {
    // Declaring and initializing a character array (C-string)
    char myString[6] = {'H', 'e', 'l', 'l', 'o', '\0'};

// Printing the C-string
    std::cout << "C-string: " << myString << std::endl;
}
Outcome:
C-string: Hello

* The character array myString is initialized with the characters of the word "Hello" and terminated by the null character ('\0').

When working with C++ strings using the 'std::string' class, the null character is handled internally, and you don't need to explicitly include it. The 'std::string' class manages the length of the string and handles null characters automatically. Here's an example:

cpp Copy Code
#include<iostream>
#include<string>

int main() {
    // Using std::string to represent a string
    std::string myString = "Hello";

    // Printing the std::string
    std::cout << "std::string: " << myString << std::endl;

    return 0;
}
Output:
std::string: Hello

* In this case, the 'std::string' class takes care of managing the null character and the length of the string.

What is New?

We have just updated this website & still working on adding new content & updating existing features.