Comparing strings in C++ is a fundamental operation in many software development tasks. This comprehensive guide, brought to you by COMPARE.EDU.VN, will delve into the various methods available for string comparison in C++, providing detailed explanations, practical examples, and insights into the underlying principles. Whether you are a student, a professional developer, or simply someone looking to enhance your C++ skills, this guide will equip you with the knowledge and tools necessary to effectively compare strings in C++.
At COMPARE.EDU.VN, our goal is to provide clear and objective comparisons, helping you make informed decisions. String comparison is critical in many fields, from data validation to sorting algorithms. This article will cover the essentials of string comparison, including the use of std::string::compare, relational operators, and more. Get ready to discover the best practices for string comparisons, essential for writing reliable and efficient C++ code.
1. Introduction to String Comparison in C++
String comparison is a core operation in computer programming, pivotal in a variety of applications ranging from simple data validation to complex algorithms. In C++, the std::string class offers several ways to compare strings, each with its own nuances and use cases. This section provides a comprehensive overview of string comparison in C++, setting the stage for a detailed exploration of the available methods and techniques.
1.1. Importance of String Comparison
String comparison is essential in diverse scenarios:
- Data Validation: Verifying user input to ensure it conforms to expected formats or values.
- Sorting Algorithms: Ordering strings alphabetically or based on other criteria.
- Searching: Finding specific strings within a larger body of text.
- Authentication: Comparing passwords or usernames against stored values.
- Configuration Files: Parsing and interpreting configuration settings.
1.2. Basic Concepts
Before diving into the specifics, understanding the fundamental concepts is crucial:
- Lexicographical Order: Strings are typically compared lexicographically, meaning character by character, based on their numerical values (e.g., ASCII or Unicode).
- Case Sensitivity: By default, string comparisons in C++ are case-sensitive. “Apple” is different from “apple”.
- Return Values: Comparison functions usually return an integer indicating the relationship between the strings:
- 0: The strings are equal.
- < 0: The first string is lexicographically less than the second string.
-
0: The first string is lexicographically greater than the second string.
1.3. Methods for String Comparison in C++
C++ provides several methods for comparing strings:
std::string::compare: A member function of thestd::stringclass, offering a flexible way to compare strings and substrings.- Relational Operators: Overloaded operators such as
==,!=,<,>,<=, and>=, providing a more intuitive syntax for comparisons. strcmp: A C-style function that compares null-terminated character arrays. While still available in C++, it’s generally recommended to usestd::stringfor better safety and functionality.
2. Using std::string::compare
The std::string::compare function is a versatile tool for string comparison in C++. It allows you to compare entire strings or specific substrings, providing detailed control over the comparison process. This section will explore the different overloads of compare and demonstrate their usage with practical examples.
2.1. Syntax and Overloads
The std::string::compare function has several overloads, each accepting different parameters:
(const string& str) const: Compares the string object with another string object.(size_t pos, size_t len, const string& str) const: Compares a substring of the string object with another string object.(size_t pos, size_t len, const string& str, size_t subpos, size_t sublen) const: Compares a substring of the string object with a substring of another string object.- *`(const char s) const`**: Compares the string object with a C-style string.
- *`(size_t pos, size_t len, const char s) const`**: Compares a substring of the string object with a C-style string.
- *`(size_t pos, size_t len, const char s, size_t n) const
**: Compares a substring of the string object with the firstn` characters of a C-style string.
2.2. Comparing Entire Strings
The simplest form of compare compares the entire string object with another string:
#include <iostream>
#include <string>
int main() {
std::string str1 = "hello";
std::string str2 = "world";
std::string str3 = "hello";
int result1 = str1.compare(str2); // Compare "hello" with "world"
int result2 = str1.compare(str3); // Compare "hello" with "hello"
if (result1 == 0) {
std::cout << "str1 and str2 are equal" << std::endl;
} else if (result1 < 0) {
std::cout << "str1 is less than str2" << std::endl;
} else {
std::cout << "str1 is greater than str2" << std::endl;
}
if (result2 == 0) {
std::cout << "str1 and str3 are equal" << std::endl;
} else if (result2 < 0) {
std::cout << "str1 is less than str3" << std::endl;
} else {
std::cout << "str1 is greater than str3" << std::endl;
}
return 0;
}Output:
str1 is less than str2
str1 and str3 are equal2.3. Comparing Substrings
You can compare substrings of strings using compare:
#include <iostream>
#include <string>
int main() {
std::string str1 = "The quick brown fox";
std::string str2 = "quick brown";
// Compare "quick brown" (starting at position 4 of str1, length 11) with str2
int result = str1.compare(4, 11, str2);
if (result == 0) {
std::cout << "The substrings are equal" << std::endl;
} else {
std::cout << "The substrings are not equal" << std::endl;
}
return 0;
}Output:
The substrings are equal2.4. Comparing with C-style Strings
compare can also be used to compare std::string objects with C-style strings (null-terminated character arrays):
#include <iostream>
#include <string>
int main() {
std::string str1 = "hello";
const char* cstr = "hello";
int result = str1.compare(cstr);
if (result == 0) {
std::cout << "str1 and cstr are equal" << std::endl;
} else {
std::cout << "str1 and cstr are not equal" << std::endl;
}
return 0;
}Output:
str1 and cstr are equal2.5. Comparing Substrings with C-style Strings
You can also compare substrings with a specified number of characters from a C-style string:
#include <iostream>
#include <string>
int main() {
std::string str1 = "hello world";
const char* cstr = "world";
// Compare "world" (starting at position 6 of str1, length 5) with the first 5 characters of cstr
int result = str1.compare(6, 5, cstr, 5);
if (result == 0) {
std::cout << "The substrings are equal" << std::endl;
} else {
std::cout << "The substrings are not equal" << std::endl;
}
return 0;
}Output:
The substrings are equal3. Relational Operators for String Comparison
C++ provides overloaded relational operators (==, !=, <, >, <=, >=) for std::string objects, offering a more intuitive and readable way to compare strings. These operators simplify the comparison process and are widely used in C++ code.
3.1. Overview of Relational Operators
Relational operators compare strings lexicographically, character by character, based on their numerical values. The operators return a boolean value (true or false) indicating the relationship between the strings.
==(Equal to): Returnstrueif the strings are equal,falseotherwise.!=(Not equal to): Returnstrueif the strings are not equal,falseotherwise.<(Less than): Returnstrueif the first string is lexicographically less than the second string,falseotherwise.>(Greater than): Returnstrueif the first string is lexicographically greater than the second string,falseotherwise.<=(Less than or equal to): Returnstrueif the first string is lexicographically less than or equal to the second string,falseotherwise.>=(Greater than or equal to): Returnstrueif the first string is lexicographically greater than or equal to the second string,falseotherwise.
3.2. Using Relational Operators
Here’s how to use relational operators to compare strings:
#include <iostream>
#include <string>
int main() {
std::string str1 = "apple";
std::string str2 = "banana";
std::string str3 = "apple";
// Equality and inequality
if (str1 == str3) {
std::cout << "str1 and str3 are equal" << std::endl;
} else {
std::cout << "str1 and str3 are not equal" << std::endl;
}
if (str1 != str2) {
std::cout << "str1 and str2 are not equal" << std::endl;
} else {
std::cout << "str1 and str2 are equal" << std::endl;
}
// Less than and greater than
if (str1 < str2) {
std::cout << "str1 is less than str2" << std::endl;
} else {
std::cout << "str1 is not less than str2" << std::endl;
}
if (str2 > str3) {
std::cout << "str2 is greater than str3" << std::endl;
} else {
std::cout << "str2 is not greater than str3" << std::endl;
}
// Less than or equal to and greater than or equal to
if (str1 <= str3) {
std::cout << "str1 is less than or equal to str3" << std::endl;
} else {
std::cout << "str1 is not less than or equal to str3" << std::endl;
}
if (str2 >= str1) {
std::cout << "str2 is greater than or equal to str1" << std::endl;
} else {
std::cout << "str2 is not greater than or equal to str1" << std::endl;
}
return 0;
}Output:
str1 and str3 are equal
str1 and str2 are not equal
str1 is less than str2
str2 is greater than str3
str1 is less than or equal to str3
str2 is greater than or equal to str13.3. Advantages of Relational Operators
- Readability: Relational operators offer a more natural and readable syntax compared to
compare. - Simplicity: They are straightforward to use, making code easier to understand and maintain.
- Common Usage: Relational operators are widely used in C++ for string comparisons, making code more consistent and familiar.
3.4. Considerations
- Case Sensitivity: Relational operators are case-sensitive. Use techniques like converting strings to lowercase for case-insensitive comparisons.
- No Substring Comparison: Relational operators compare entire strings. For substring comparisons, use
std::string::compare.
4. Case-Insensitive String Comparison
By default, C++ string comparisons are case-sensitive. However, many applications require case-insensitive comparisons, where “apple” is considered equal to “Apple”. This section will explore techniques for performing case-insensitive string comparisons in C++.
4.1. Converting Strings to Lowercase or Uppercase
One common approach is to convert both strings to either lowercase or uppercase before comparing them. This ensures that the case difference is eliminated.
#include <iostream>
#include <string>
#include <algorithm>
#include <cctype>
// Function to convert a string to lowercase
std::string toLower(const std::string& str) {
std::string result = str;
std::transform(result.begin(), result.end(), result.begin(), ::tolower);
return result;
}
int main() {
std::string str1 = "Apple";
std::string str2 = "apple";
std::string lowerStr1 = toLower(str1);
std::string lowerStr2 = toLower(str2);
if (lowerStr1 == lowerStr2) {
std::cout << "str1 and str2 are equal (case-insensitive)" << std::endl;
} else {
std::cout << "str1 and str2 are not equal (case-insensitive)" << std::endl;
}
return 0;
}Output:
str1 and str2 are equal (case-insensitive)4.2. Using std::transform with ::tolower or ::toupper
The std::transform function from the <algorithm> header, combined with ::tolower or ::toupper from the <cctype> header, is used to convert strings.
std::transform: Applies a function to a range of elements and stores the results in another range.::tolower: Converts a character to its lowercase equivalent.::toupper: Converts a character to its uppercase equivalent.
4.3. Custom Comparison Functions
Another approach is to write a custom comparison function that compares characters in a case-insensitive manner.
#include <iostream>
#include <string>
#include <cctype>
// Function to compare two characters in a case-insensitive manner
bool caseInsensitiveCharCompare(char c1, char c2) {
return std::tolower(c1) == std::tolower(c2);
}
// Function to compare two strings in a case-insensitive manner
bool caseInsensitiveStringCompare(const std::string& str1, const std::string& str2) {
if (str1.length() != str2.length()) {
return false;
}
for (size_t i = 0; i < str1.length(); ++i) {
if (!caseInsensitiveCharCompare(str1[i], str2[i])) {
return false;
}
}
return true;
}
int main() {
std::string str1 = "Apple";
std::string str2 = "apple";
if (caseInsensitiveStringCompare(str1, str2)) {
std::cout << "str1 and str2 are equal (case-insensitive)" << std::endl;
} else {
std::cout << "str1 and str2 are not equal (case-insensitive)" << std::endl;
}
return 0;
}Output:
str1 and str2 are equal (case-insensitive)4.4. Using Locale-Specific Comparisons
For more advanced case-insensitive comparisons that consider locale-specific rules, you can use the <locale> header.
#include <iostream>
#include <string>
#include <locale>
#include <algorithm>
// Function to perform case-insensitive comparison using a locale
bool caseInsensitiveLocaleCompare(const std::string& str1, const std::string& str2) {
std::locale loc;
if (str1.length() != str2.length()) {
return false;
}
for (size_t i = 0; i < str1.length(); ++i) {
if (std::tolower(str1[i], loc) != std::tolower(str2[i], loc)) {
return false;
}
}
return true;
}
int main() {
std::string str1 = "Straße";
std::string str2 = "strasse";
if (caseInsensitiveLocaleCompare(str1, str2)) {
std::cout << "str1 and str2 are equal (case-insensitive, locale-aware)" << std::endl;
} else {
std::cout << "str1 and str2 are not equal (case-insensitive, locale-aware)" << std::endl;
}
return 0;
}Output may vary depending on the locale settings.
4.5. Considerations
- Performance: Converting strings to lowercase or uppercase can have a performance impact, especially for large strings. Consider caching the lowercase or uppercase versions if you need to perform multiple comparisons.
- Locale Awareness: For applications that need to handle different languages and character sets, locale-specific comparisons are essential.
- Unicode Support: Ensure that your case-insensitive comparison methods correctly handle Unicode characters.
5. Comparing C-style Strings with strcmp
While std::string is the preferred way to handle strings in C++, C-style strings (null-terminated character arrays) are still encountered in some contexts. The strcmp function from the <cstring> header is used to compare C-style strings.
5.1. Overview of strcmp
The strcmp function compares two C-style strings lexicographically.
#include <iostream>
#include <cstring>
int main() {
const char* str1 = "hello";
const char* str2 = "world";
const char* str3 = "hello";
int result1 = strcmp(str1, str2); // Compare "hello" with "world"
int result2 = strcmp(str1, str3); // Compare "hello" with "hello"
if (result1 == 0) {
std::cout << "str1 and str2 are equal" << std::endl;
} else if (result1 < 0) {
std::cout << "str1 is less than str2" << std::endl;
} else {
std::cout << "str1 is greater than str2" << std::endl;
}
if (result2 == 0) {
std::cout << "str1 and str3 are equal" << std::endl;
} else if (result2 < 0) {
std::cout << "str1 is less than str3" << std::endl;
} else {
std::cout << "str1 is greater than str3" << std::endl;
}
return 0;
}Output:
str1 is less than str2
str1 and str3 are equal5.2. Return Value of strcmp
The strcmp function returns an integer indicating the relationship between the strings:
- 0: The strings are equal.
- < 0: The first string is lexicographically less than the second string.
-
0: The first string is lexicographically greater than the second string.
5.3. Using strncmp for Partial Comparison
The strncmp function allows you to compare a specified number of characters from two C-style strings.
#include <iostream>
#include <cstring>
int main() {
const char* str1 = "hello world";
const char* str2 = "hello there";
// Compare the first 5 characters of str1 and str2
int result = strncmp(str1, str2, 5);
if (result == 0) {
std::cout << "The first 5 characters of str1 and str2 are equal" << std::endl;
} else {
std::cout << "The first 5 characters of str1 and str2 are not equal" << std::endl;
}
return 0;
}Output:
The first 5 characters of str1 and str2 are equal5.4. Considerations
- Safety:
strcmpandstrncmpare less safe thanstd::stringbecause they operate on raw pointers and do not perform bounds checking. Buffer overflows can occur if the strings are not null-terminated or if the specified length instrncmpis too large. - Null Termination: Ensure that the C-style strings are properly null-terminated. Otherwise,
strcmpmay read beyond the end of the allocated memory. - Modern C++: In modern C++, it’s generally recommended to use
std::stringfor better safety and functionality.
6. Performance Considerations
String comparison can be a performance-critical operation in some applications, especially when dealing with large strings or performing many comparisons. This section will discuss performance considerations and offer tips for optimizing string comparison in C++.
6.1. Comparing std::string vs. C-style Strings
std::string generally offers better performance and safety compared to C-style strings due to its optimized implementation and automatic memory management. Using std::string is almost always recommended unless you have a very specific reason to use C-style strings.
6.2. Short-Circuiting Comparisons
When using relational operators, C++ employs short-circuiting evaluation. If the first characters of two strings are different, the comparison can terminate immediately without examining the rest of the string. This can significantly improve performance when comparing many strings with different prefixes.
6.3. Caching String Lengths
Calculating the length of a string can be an expensive operation, especially for long strings. If you need to compare a string multiple times, consider caching its length to avoid repeated calculations.
#include <iostream>
#include <string>
int main() {
std::string str = "This is a long string";
size_t length = str.length(); // Cache the length
for (int i = 0; i < 1000; ++i) {
if (str.length() != length) { // Use the cached length
std::cout << "String length has changed" << std::endl;
}
}
return 0;
}6.4. Using Hash Codes for Quick Equality Checks
For equality checks, you can use hash codes to quickly determine if two strings are different. If the hash codes are different, the strings are guaranteed to be different. However, if the hash codes are the same, you still need to perform a full string comparison to confirm equality due to the possibility of hash collisions.
#include <iostream>
#include <string>
#include <functional>
int main() {
std::string str1 = "hello";
std::string str2 = "world";
std::string str3 = "hello";
std::hash<std::string> hashFunction;
size_t hash1 = hashFunction(str1);
size_t hash2 = hashFunction(str2);
size_t hash3 = hashFunction(str3);
if (hash1 != hash2) {
std::cout << "str1 and str2 are not equal (based on hash)" << std::endl;
} else {
std::cout << "str1 and str2 may be equal (hash collision)" << std::endl;
}
if (hash1 == hash3) {
if (str1 == str3) {
std::cout << "str1 and str3 are equal" << std::endl;
} else {
std::cout << "str1 and str3 have the same hash but are not equal (hash collision)" << std::endl;
}
} else {
std::cout << "str1 and str3 are not equal (based on hash)" << std::endl;
}
return 0;
}6.5. SIMD Instructions
Modern processors support SIMD (Single Instruction, Multiple Data) instructions, which can perform multiple comparisons in parallel. Some C++ libraries and compilers can automatically take advantage of SIMD instructions to accelerate string comparisons.
6.6. Profiling and Benchmarking
The most effective way to optimize string comparison is to profile your code and benchmark different approaches. Use profiling tools to identify the hotspots in your code and measure the performance of different comparison methods.
7. Advanced String Comparison Techniques
Beyond the basic methods, there are advanced techniques for string comparison that can be useful in specific scenarios. This section will explore some of these techniques, including regular expressions, fuzzy string matching, and custom comparison criteria.
7.1. Regular Expressions
Regular expressions are a powerful tool for pattern matching and can be used to perform complex string comparisons. The <regex> header in C++ provides support for regular expressions.
#include <iostream>
#include <string>
#include <regex>
int main() {
std::string str = "The quick brown fox jumps over the lazy dog";
std::regex pattern("fox.*lazy"); // Regular expression to match "fox" followed by "lazy"
if (std::regex_search(str, pattern)) {
std::cout << "String matches the regular expression" << std::endl;
} else {
std::cout << "String does not match the regular expression" << std::endl;
}
return 0;
}Output:
String matches the regular expression7.2. Fuzzy String Matching
Fuzzy string matching, also known as approximate string matching, is a technique for finding strings that are similar to a given pattern, even if they are not exactly the same. This is useful for correcting typos, handling variations in spelling, and dealing with noisy data.
#include <iostream>
#include <string>
#include <vector>
#include <algorithm>
// Function to calculate Levenshtein distance between two strings
int levenshteinDistance(const std::string& s1, const std::string& s2) {
const size_t len1 = s1.size(), len2 = s2.size();
std::vector<std::vector<int>> d(len1 + 1, std::vector<int>(len2 + 1));
for (size_t i = 0; i <= len1; ++i) d[i][0] = i;
for (size_t j = 0; j <= len2; ++j) d[0][j] = j;
for (size_t i = 1; i <= len1; ++i) {
for (size_t j = 1; j <= len2; ++j) {
if (s1[i - 1] == s2[j - 1]) {
d[i][j] = d[i - 1][j - 1];
} else {
d[i][j] = 1 + std::min({d[i - 1][j], d[i][j - 1], d[i - 1][j - 1]});
}
}
}
return d[len1][len2];
}
int main() {
std::string str1 = "kitten";
std::string str2 = "sitting";
int distance = levenshteinDistance(str1, str2);
std::cout << "Levenshtein distance between "" << str1 << "" and "" << str2 << "" is: " << distance << std::endl;
return 0;
}Output:
Levenshtein distance between "kitten" and "sitting" is: 37.3. Custom Comparison Criteria
Sometimes, you may need to compare strings based on custom criteria that are not supported by the standard comparison methods. In such cases, you can define your own comparison functions or classes.
#include <iostream>
#include <string>
#include <algorithm>
// Custom comparison function to compare strings based on length
bool compareByLength(const std::string& str1, const std::string& str2) {
return str1.length() < str2.length();
}
int main() {
std::string str1 = "apple";
std::string str2 = "banana";
if (compareByLength(str1, str2)) {
std::cout << "str1 is shorter than str2" << std::endl;
} else {
std::cout << "str1 is not shorter than str2" << std::endl;
}
return 0;
}Output:
str1 is shorter than str28. Common Mistakes and How to Avoid Them
String comparison in C++ can be tricky, and it’s easy to make mistakes that can lead to unexpected behavior. This section will discuss common mistakes and provide tips on how to avoid them.
8.1. Mixing std::string and C-style Strings
Mixing std::string and C-style strings can lead to confusion and errors. Always use std::string when possible and be careful when converting between the two types.
8.2. Ignoring Case Sensitivity
Forgetting that string comparisons are case-sensitive by default can lead to incorrect results. Always consider whether you need a case-insensitive comparison and use the appropriate techniques.
8.3. Buffer Overflows with strcmp
Using strcmp with C-style strings without ensuring null termination can lead to buffer overflows. Always ensure that C-style strings are properly null-terminated.
8.4. Incorrectly Handling Return Values
Misinterpreting the return values of comparison functions can lead to incorrect logic. Always check the documentation and understand the meaning of the return values.
8.5. Not Considering Locale-Specific Rules
For applications that need to handle different languages and character sets, not considering locale-specific rules can lead to incorrect comparisons. Always use locale-aware comparison methods when necessary.
9. Best Practices for String Comparison
Following best practices can help you write robust and efficient code for string comparison in C++. This section will summarize the best practices discussed throughout this guide.
9.1. Use std::string for String Handling
Always prefer std::string over C-style strings for better safety, functionality, and performance.
9.2. Choose the Right Comparison Method
Select the appropriate comparison method based on your specific needs. Use relational operators for simple comparisons, std::string::compare for more control, and regular expressions for complex pattern matching.
9.3. Consider Case Sensitivity
Always consider whether you need a case-insensitive comparison and use the appropriate techniques.
9.4. Optimize for Performance
Optimize string comparison for performance by caching string lengths, using hash codes for quick equality checks, and profiling your code.
9.5. Handle Errors and Exceptions
Handle errors and exceptions gracefully, especially when dealing with C-style strings and user input.
9.6. Document Your Code
Document your code clearly and explain the purpose and behavior of your string comparison logic.
10. Conclusion
String comparison is a fundamental operation in C++ programming, and mastering the various methods and techniques is essential for writing robust and efficient code. This guide has provided a comprehensive overview of string comparison in C++, covering the use of std::string::compare, relational operators, C-style strings, case-insensitive comparisons, performance considerations, and advanced techniques. By following the best practices outlined in this guide, you can confidently tackle any string comparison task in C++.
Remember that the choice of comparison method depends on the specific requirements of your application. Consider factors such as performance, case sensitivity, locale awareness, and the complexity of the comparison criteria.
At compare.edu.vn, we are committed to providing you with the best resources and guidance for mastering C++ programming. We encourage you to explore our website for more articles, tutorials, and comparisons to enhance your skills and knowledge.
FAQ: String Comparison in C++
Here are some frequently asked questions about string comparison in C++, along with detailed answers.
Q1: What is the difference between std::string::compare and relational operators for string comparison?
A1: std::string::compare is a member function that provides more control over the comparison process, allowing you to compare substrings and specify the comparison criteria. Relational operators (==, !=, <, >, <=, >=) offer a more intuitive syntax for comparing entire strings.
Q2: How can I perform a case-insensitive string comparison in C++?
A2: You can perform a case-insensitive string comparison by converting both strings to either lowercase or uppercase before comparing them, using a custom comparison function, or using locale-specific comparisons.
Q3: When should I use strcmp instead of std::string for string comparison?
A3: In modern C++, it’s generally recommended to use std::string for better safety and functionality. Use strcmp only when you have a specific reason to work with C-style strings, such as compatibility with legacy code or performance-critical scenarios where you have carefully optimized the code.
Q4: How can I optimize string comparison for performance?
A4: You can optimize string comparison for performance by caching string lengths, using hash codes for quick equality checks, and taking advantage of SIMD instructions. Profiling your code is essential to identify performance bottlenecks.
Q5: What is fuzzy string matching, and when is it useful?
A5: Fuzzy string matching is a technique for finding strings that are similar to a given pattern, even if they are not exactly the same. This is useful for correcting typos, handling variations in spelling, and dealing with noisy data.
Q6: How can I compare strings based on custom criteria?
A6: You can compare strings based on custom criteria by defining your own comparison functions or classes that implement the desired comparison logic.
Q7: What are some common mistakes to avoid when comparing strings in C++?
A7: Common mistakes include mixing std::string and C-style strings, ignoring case sensitivity, causing buffer overflows with strcmp, incorrectly handling return values, and not considering locale-specific rules.
Q8: How can I handle errors and exceptions when comparing strings?
A8: Handle errors and exceptions gracefully, especially when dealing with C-style strings and user input. Use try-catch blocks to catch exceptions and validate
