Metadata

📅 Date :: 12-06-2025
🏷️ Tags :: cpp

Notes

Detailed and Elaborative Notes on Entering User Input into an Array in C++

In this topic, the focus is on how to accept user input and store it in an array. The example provided uses an array of strings to demonstrate how we can allow users to input food items into an array. The process involves using loops, conditionals, and handling user input efficiently, especially when considering constraints like array size and the need to break out of the loop early. Let’s dive into the key aspects and steps involved in implementing this.

1. Declaring an Array of Fixed Size

We start by creating an array of strings to store food names.
```
std::string foods[5];
 
```
This declares an array foods of size 5, where each element will hold a food item (string).

2. Calculating the Size of the Array

We calculate the size of the array using the sizeof operator:
```
int size = sizeof(foods) / sizeof(foods[0]);
 
```
The sizeof(foods) gives the total size of the array, and dividing it by the size of one element (foods[0]) will give us the number of elements in the array (in this case, 5).

3. Accepting User Input Using a Loop

A for loop is used to iterate through the array and accept user input for each food item.
```
for (int i = 0; i < size; ++i) {
    std::cout << "Enter a food you like #" << i + 1 << ": ";
    std::getline(std::cin, foods[i]);
}
 
```
- std::getline(): This function is used to take input from the user, allowing them to enter an entire line, including spaces. This is important because food names may contain spaces, and std::cin would only capture up to the first space without getline().

4. Displaying the User’s Input

After collecting the food items, we use a loop to display what the user entered:

std::cout << "You like the following foods: " << std::endl;
//for (const auto& food : foods) {
for (std::string food : foods)
    std::cout << food << std::endl;
}

The for-each loop here iterates through the array and prints each food item.

5. Handling Early Termination (Quit Option)

If the user wants to stop entering food items early (before the array is full), we can add a quit option. For this, we check if the input is "Q" (or another special character) and break out of the loop:
```
std::string temp;
std::cout << "Enter a food you like or Q to quit: ";
std::getline(std::cin, temp);
if (temp == "Q") {
    break;
}else{
	foods[i] = temp;
}
 
```
- The input is first stored in a temporary variable temp. If the input is "Q", the loop is terminated early with the break statement. This prevents the string "Q" from being added to the foods array.
- If the input is not "Q", it is stored in the foods array at the current index.

6. Preventing Empty or Unused Array Slots from Displaying

After the user exits the input loop, there might be empty slots in the array where no input was stored (e.g., if the user quit early). To avoid displaying these empty slots, we use a condition check to see if an element is empty before displaying it:
```
//for (int i = 0; i < size; ++i) {
//    if (!foods[i].empty()) {
for(int i=0; !foods[i].empty(); i++){
        std::cout << foods[i] << std::endl;
    }
}
 
```
- empty() function: This function returns true if the string is empty (i.e., no input was stored), and false otherwise.
- The loop checks each element of the array, and if it is not empty, it is printed. This ensures that only valid food entries are shown.

7. Limitation of Static Arrays

One important point discussed is the limitation of static arrays. A static array has a fixed size, meaning once it is declared (in this case, foods[5]), the size cannot be changed during the program’s execution.
- Problem: If the user wants to enter more than five food items, they cannot do so because the array is static. This is a constraint of arrays in C++.
- Potential Solution: To overcome this, dynamic memory allocation (using pointers) or vectors can be used. Vectors are dynamic arrays that can grow and shrink in size as needed, allowing for more flexibility.

8. Code Example with Explanation

Here’s the complete example with the discussed logic:

#include <iostream>
#include <string>
 
int main() {
    // Declaring an array of strings
    std::string foods[5];
    int size = sizeof(foods) / sizeof(foods[0]); // Calculating array size
 
    // Loop to get user input
    for (int i = 0; i < size; ++i) {
        std::cout << "Enter a food you like #" << i + 1 << ": ";
        std::string temp;
        std::getline(std::cin, temp);
 
        // If user enters "Q", break out of the loop
        if (temp == "Q") {
            break;
        }else{
					foods[i] = temp; // Store input in the array
				}
    }
 
    // Display the list of foods entered by the user
    std::cout << "You like the following foods: " << std::endl;
    for (int i = 0; i < size; ++i) {
        if (!foods[i].empty()) { // Avoid displaying empty slots
            std::cout << foods[i] << std::endl;
        }
    }
 
    return 0;
}

9. Additional Points and Considerations

Dynamic Memory: If the user input needs to be more flexible, dynamic memory allocation (like using pointers and new) or vectors (from the Standard Template Library) would be ideal. With vectors, the size can be dynamically adjusted during runtime, so the program is not restricted by a fixed array size.
Vector Alternative: If we used a std::vector instead of an array, it would look like this:

#include <iostream>
#include <string>
#include <vector>
 
int main() {
	std::vector<std::string> foods;  // Dynamic array (vector)
	std::string temp;
 
	while (true) {
		std::cout << "Enter a food you like or Q to quit: ";
		std::getline(std::cin, temp);
 
		if (temp == "Q") {
			break;
		}
 
		foods.push_back(temp);  // Add input to vector
	}
 
	std::cout << "You like the following foods: " << std::endl;
	for (const auto& food : foods) {
		std::cout << food << std::endl;
	}
 
	return 0;
}

push_back(): Adds elements to the end of the vector, making it grow as needed.

Conclusion

This method of accepting user input and storing it in an array (or vector) is an excellent beginner approach. However, the main takeaway is that arrays have limitations due to their static nature, and for more dynamic handling of data, using vectors or other dynamic structures is recommended. This approach also introduces essential concepts like handling user input, breaking out of loops, and preventing empty values from being displayed.

References

Video

Quartz 4

Explorer

C++ How to fill an array with user input 🌭