substr() In C++ | Syntax, Use Cases, Tips, & More (+Code Examples)

0 min read

The substr() function in C++ programming language is one of the string methods used to get a part of the original string. It is a predefined method in the standard library and is used for string slicing and handling other string operations like append(), strcat(), etc. In this blog, we will discuss the syntax, use cases/applications, and more about the substr() function in C++ with the help of examples. So let’s get started!

What Is A Substring In C++ (Substr C++)?

To begin with, a substring refers to a part of the longer string. The substr() function in C++ extracts a portion of a string as a newly constructed string. It’s a member of the std::string class, defined in <string>. It is a powerful tool that helps with string slicing, and it is ideal for extracting substrings for further processing.

The substr in C++ takes two parameters, the starting index and the length of the substring we want from that index, and then it returns a new string object to construct a substring from the original string. Let's take a look at its syntax, components, and return types, followed by an example.

Syntax of substr() Function in C++

string substr(starting_pos, len_substr)

Here:

1. The string keyword indicates that the return type of substr() function is a string.
2. starting_pos: an unsigned Integer type input parameter. It denotes the position of the first character to be copied from the original string. (Note that the pos parameter is the position parameter, i.e., it refers to the position from which we want the substring to start.)
3. len_substr: an unsigned Integer type input parameter denotes the length of the substring.

Return Type

The substr() function in cpp programming returns a newly constructed object of type String, i.e., std::string containing the extracted substring. Case handling:

• If pos equals the string’s length → returns an empty string.
• If pos exceeds the length → throws std::out_of_range.
• If len stretches past the string’s end → grabs characters until the end. No exception.

Example for substr() in C++ | Finding Substring Using Positive and Negative Indices

Let's understand the substr in C++ using the following example:

            #include 
#include 
using namespace std;

int main() {
string originalString = "#Unstoppable"; //original string
string substr1 = originalString.substr(1, 6); //substring starting from index 1 and length 6
string substr2 = originalString.substr(8, -2); //substring starting from index 8 and length -2

cout << "Substring1 starting at position 1 and length 6 is: " << substr1 << endl;
cout << "Substring2 starting at position 8 and length -2 is: " << substr2 << endl;

return 0;
}
          

I2luY2x1ZGUgPGlvc3RyZWFtPgojaW5jbHVkZSA8c3RyaW5nLmg+CnVzaW5nIG5hbWVzcGFjZSBzdGQ7CgppbnQgbWFpbigpIHsKc3RyaW5nIG9yaWdpbmFsU3RyaW5nID0gIiNVbnN0b3BwYWJsZSI7IC8vb3JpZ2luYWwgc3RyaW5nCnN0cmluZyBzdWJzdHIxID0gb3JpZ2luYWxTdHJpbmcuc3Vic3RyKDEsIDYpOyAvL3N1YnN0cmluZyBzdGFydGluZyBmcm9tIGluZGV4IDEgYW5kIGxlbmd0aCA2CnN0cmluZyBzdWJzdHIyID0gb3JpZ2luYWxTdHJpbmcuc3Vic3RyKDgsIC0yKTsgLy9zdWJzdHJpbmcgc3RhcnRpbmcgZnJvbSBpbmRleCA4IGFuZCBsZW5ndGggLTIKCmNvdXQgPDwgIlN1YnN0cmluZzEgc3RhcnRpbmcgYXQgcG9zaXRpb24gMSBhbmQgbGVuZ3RoIDYgaXM6ICIgPDwgc3Vic3RyMSA8PCBlbmRsOwpjb3V0IDw8ICJTdWJzdHJpbmcyIHN0YXJ0aW5nIGF0IHBvc2l0aW9uIDggYW5kIGxlbmd0aCAtMiBpczogIiA8PCBzdWJzdHIyIDw8IGVuZGw7CgpyZXR1cm4gMDsKfQ==

Output:

Substr1 starting at position 1 and length 6 is: Unstop
Substr2 starting at position 8 and length -2 is: able

Explanation:

We begin by including the <iostream> and <string.h> header files.

1. In the main() function, we define a string, originalString, and assign the value "#Unstoppable" to it.
2. We then use the C++ substr() to get two substrings of the original:
   • In the first case, since the starting index is 1, it implies that the substring1 starts from ‘U’ and ends at the 6th index, which is ‘p’, giving a substring of length 6.
   • In the second case, since the length is -2, which is a negative number, the substr function will take all the characters till the end of the string. This is because the parameters of substr() function only take unsigned_integer type values.
3. Next, we use the cout statements to print the substrings to the console.
4. The results match our expectations: sub1 is exactly six characters from index 1, and sub2 contains everything from index 8 onwards.
5. Finally, the main() function closes with a return 0 statement. 

Check this out: Boosting Career Opportunities For Engineers Through E-School Competitions

Understanding substr() Basics with Examples

Let’s explore some edge-case examples to better understand how substr() works in C++. Consider a string s = “Unstoppable”. Then the indexes of each character in the sequence of characters in the string will be as follows:

string: U n s t o p p a b l e
index: 0 1 2 3 4 5 6 7 8 9 10

Now consider these cases:

1. s.substr(s.begin(), 5)
   ❌ Compilation Error
   Explanation: s.begin() returns an iterator, not an integer. substr() requires an unsigned integer (size_t) as the starting position.
2. s.substr(2, 3)
   ✅ Result: "sto"
   Explanation: the substr() starts at index 2 ('s') and includes 3 characters: 's', 't', 'o'.
3. s.substr(*s.begin() - s[0], 6)
   ✅ Result: "Unstop"
   Explanation: *s.begin() yields 'U'; subtracting s[0] (also 'U') equals 0. So, this effectively calls substr(0, 6).
4. s.substr(2, 0)
   ✅ Result: "" (empty string)
   Explanation: starting at index 2 but taking 0 characters returns an empty string.
   

Use Cases/ Examples of substr() in C++

The substr() function shines in a variety of real-world string operations, from simple extraction to numeric manipulation. Here's a quick overview of the examples and use cases we'll explore in this section:

• Get a Substring Before a Character: Extracts the part of a string that appears before a specified delimiter.
• All Substrings of a Given String: Iterates through and prints every possible non-empty substring of a string—useful for parsing or analysis tasks
• Sum of All Substrings of a String Representing a Number: Treats each substring as a number and prints the total sum, adding a numeric twist to substring operations.
• Minimum Value of All Substrings of a Numeric String: Finds and outputs the smallest numeric value among all substrings.
  
• Maximum Value of All Substrings of a Numeric String: Finds and outputs the largest numeric value among all substrings.
• Substring After a Given Character: Extracts the part of a string that appears after a specified delimiter.

Each of these tasks leverages substr() in different ways, demonstrating its versatility—from text parsing to numeric processing. We’ll dive into each example shortly!

How to Get a Substring Before a Character Using substr() in C++?

Let’s assume that you have been given a string and a character. Your task is to print the sub-string followed by the given character. The example below shows how this can be done:

Code Example:

            // C++ program to demonstrate functioning of substr()
#include 
#include 
using namespace std;

int main(){
// Take any string
string s = "Hardwork:Success";

// Find position of ':' using find()
int pos = s.find(":");

// Copy substring before pos
// Extract everything before the ":" in the given string
string sub = s.substr(0, pos);

// prints the result
cout << "String is: " << sub;

return 0;
}
          

Ly8gQysrIHByb2dyYW0gdG8gZGVtb25zdHJhdGUgZnVuY3Rpb25pbmcgb2Ygc3Vic3RyKCkKI2luY2x1ZGUgPGlvc3RyZWFtPgojaW5jbHVkZSA8c3RyaW5nLmg+CnVzaW5nIG5hbWVzcGFjZSBzdGQ7CgppbnQgbWFpbigpewovLyBUYWtlIGFueSBzdHJpbmcKc3RyaW5nIHMgPSAiSGFyZHdvcms6U3VjY2VzcyI7CgovLyBGaW5kIHBvc2l0aW9uIG9mICc6JyB1c2luZyBmaW5kKCkKaW50IHBvcyA9IHMuZmluZCgiOiIpOwoKLy8gQ29weSBzdWJzdHJpbmcgYmVmb3JlIHBvcwovLyBFeHRyYWN0IGV2ZXJ5dGhpbmcgYmVmb3JlIHRoZSAiOiIgaW4gdGhlIGdpdmVuIHN0cmluZwpzdHJpbmcgc3ViID0gcy5zdWJzdHIoMCwgcG9zKTsKCi8vIHByaW50cyB0aGUgcmVzdWx0CmNvdXQgPDwgIlN0cmluZyBpczogIiA8PCBzdWI7CgpyZXR1cm4gMDsKfQ==

Output:

String is: Hardwork

Explanation: 

In this example, we begin with the string s (value "Hardwork:Success")

1. We then use the find() function to get the index position of the character (:) and store it in the pos variable.
2. Next, we use the substr() function to extract the substring from index 0 to pos.
3. Here, we are extracting the substring before the delimiter (:) character.
4. We store this substring in the variable sub and then print it to the console using the cout statement.

Use substr() in C++ to Print all Substrings of a Given String

Let’s learn how to obtain all possible substrings from a given string.

Example Code:

            // C++ program to print all possible substrings of a given string
#include <bits/stdc++.h>
using namespace std;

// Function to print all the sub strings
void subString(string s, int length){
// Pick the starting point in outer loop and vary the lengths of
// different strings for a given starting point in the inner loop
for (int i = 0; i < length; i++)
for (int len = 1; len <= length - i; len++)
cout << s.substr(i, len) << endl;
}

// Driver program to test the above function
int main(){

string s = "code";
subString(s, s.length());

return 0;
}
          

Ly8gQysrIHByb2dyYW0gdG8gcHJpbnQgYWxsIHBvc3NpYmxlIHN1YnN0cmluZ3Mgb2YgYSBnaXZlbiBzdHJpbmcKI2luY2x1ZGUgPGJpdHMvc3RkYysrLmg+CnVzaW5nIG5hbWVzcGFjZSBzdGQ7CgovLyBGdW5jdGlvbiB0byBwcmludCBhbGwgdGhlIHN1YiBzdHJpbmdzCnZvaWQgc3ViU3RyaW5nKHN0cmluZyBzLCBpbnQgbGVuZ3RoKXsKLy8gUGljayB0aGUgc3RhcnRpbmcgcG9pbnQgaW4gb3V0ZXIgbG9vcCBhbmQgdmFyeSB0aGUgbGVuZ3RocyBvZgovLyBkaWZmZXJlbnQgc3RyaW5ncyBmb3IgYSBnaXZlbiBzdGFydGluZyBwb2ludCBpbiB0aGUgaW5uZXIgbG9vcApmb3IgKGludCBpID0gMDsgaSA8IGxlbmd0aDsgaSsrKQpmb3IgKGludCBsZW4gPSAxOyBsZW4gPD0gbGVuZ3RoIC0gaTsgbGVuKyspCmNvdXQgPDwgcy5zdWJzdHIoaSwgbGVuKSA8PCBlbmRsOwp9CgovLyBEcml2ZXIgcHJvZ3JhbSB0byB0ZXN0IHRoZSBhYm92ZSBmdW5jdGlvbgppbnQgbWFpbigpewoKc3RyaW5nIHMgPSAiY29kZSI7CnN1YlN0cmluZyhzLCBzLmxlbmd0aCgpKTsKCnJldHVybiAwOwp9

Output:

c
co
cod
code
o
od
ode
d
de
e

Explanation:

In this example, we begin by defining a function, subString, which takes a string and an integer as parameters.

• The function uses a set of nested for loops to iterate through the string.
• Here, the outer loop determines the starting point, and the inner loop determines the length of the substring to be extracted.
• In every iteration, we use the substr() function with the cout statement to extract and display the substring to the console.
• In the main() function, we define a string variable, s, with the value "code".
• Then, we call the subString() function, passing the string s, and the length of the string (using length() function) to is as arguments.
• The possible substrings of string “code" are { c, co, cod, code, o, od, ode, d, de, e}. We vary the starting point in the outer loop and the lengths of the substring in the inner loop.

Print Sum of all Substrings of a String Representing a Number

Suppose we have been provided with an integer represented as a string, and we have been asked to get the sum of all possible substrings of this string. We can do this using the following:

Code Example:

            #include <bits/stdc++.h>
using namespace std;

// Method to convert digit in character format to integer digit
int toDigit(char ch){
return (ch - '0');
}

// Function that returns sum of all substring of string num
int sum_Substrings(string num){
int n = num.length();
// allocating memory equal to length of the string
int sumofdigits[n];
// initialize first value with first digit in the string
sumofdigits[0] = toDigit(num[0]);
int result = sumofdigits[0];
// loop over all digits of string
for (int i = 1; i < n; i++) {
int numi = toDigit(num[i]);
// update each sumofdigits with the previous value
sumofdigits[i] = (i + 1) * numi + 10 * sumofdigits[i - 1];
// adding current value to the result
result += sumofdigits[i];
}
return result;
}


// Driver code to test above methods
int main(){

string num = "423";
cout << sum_Substrings(num) << endl;

return 0;
}
          

I2luY2x1ZGUgPGJpdHMvc3RkYysrLmg+CnVzaW5nIG5hbWVzcGFjZSBzdGQ7CgovLyBNZXRob2QgdG8gY29udmVydCBkaWdpdCBpbiBjaGFyYWN0ZXIgZm9ybWF0IHRvIGludGVnZXIgZGlnaXQKaW50IHRvRGlnaXQoY2hhciBjaCl7CnJldHVybiAoY2ggLSAnMCcpOwp9CgovLyBGdW5jdGlvbiB0aGF0IHJldHVybnMgc3VtIG9mIGFsbCBzdWJzdHJpbmcgb2Ygc3RyaW5nIG51bQppbnQgc3VtX1N1YnN0cmluZ3Moc3RyaW5nIG51bSl7CmludCBuID0gbnVtLmxlbmd0aCgpOwovLyBhbGxvY2F0aW5nIG1lbW9yeSBlcXVhbCB0byBsZW5ndGggb2YgdGhlIHN0cmluZwppbnQgc3Vtb2ZkaWdpdHNbbl07Ci8vIGluaXRpYWxpemUgZmlyc3QgdmFsdWUgd2l0aCBmaXJzdCBkaWdpdCBpbiB0aGUgc3RyaW5nCnN1bW9mZGlnaXRzWzBdID0gdG9EaWdpdChudW1bMF0pOwppbnQgcmVzdWx0ID0gc3Vtb2ZkaWdpdHNbMF07Ci8vIGxvb3Agb3ZlciBhbGwgZGlnaXRzIG9mIHN0cmluZwpmb3IgKGludCBpID0gMTsgaSA8IG47IGkrKykgewppbnQgbnVtaSA9IHRvRGlnaXQobnVtW2ldKTsKLy8gdXBkYXRlIGVhY2ggc3Vtb2ZkaWdpdHMgd2l0aCB0aGUgcHJldmlvdXMgdmFsdWUKc3Vtb2ZkaWdpdHNbaV0gPSAoaSArIDEpICogbnVtaSArIDEwICogc3Vtb2ZkaWdpdHNbaSAtIDFdOwovLyBhZGRpbmcgY3VycmVudCB2YWx1ZSB0byB0aGUgcmVzdWx0CnJlc3VsdCArPSBzdW1vZmRpZ2l0c1tpXTsKfQpyZXR1cm4gcmVzdWx0Owp9CgoKLy8gRHJpdmVyIGNvZGUgdG8gdGVzdCBhYm92ZSBtZXRob2RzCmludCBtYWluKCl7CgpzdHJpbmcgbnVtID0gIjQyMyI7CmNvdXQgPDwgc3VtX1N1YnN0cmluZ3MobnVtKSA8PCBlbmRsOwoKcmV0dXJuIDA7Cn0=

Output:

497

Explanation: The number value of all substrings are { 4, 42, 423, 2, 23, 3 }, and the sum of these substrings is 497.

Minimum Value of all Substrings of a String Representing a Number

We have been given an integer represented as a string. Now our task is to get the minimum of all possible substrings of the given string, which is representing a number.

Code Example:

            // C++ program to print the minimum of all the
// substrings of a given string representing a number
#include <bits/stdc++.h>
using namespace std;

void subString(string s, int length){
vector v;
// finding all possible substrings
for (int i = 0; i < length; i++){
for (int len = 1; len <= length - i; len++){
string sub_str =(s.substr(i, len));
int x=stoi(sub_str); // converting to integer format
v.push_back(x);//inserting into a vector
}
}
cout<<*min_element(v.begin(),v.end())<<endl;
}

// Driver program to test above function
int main(){

string s = "9328";
subString(s, s.length());

return 0;

          

Ly8gQysrIHByb2dyYW0gdG8gcHJpbnQgdGhlIG1pbmltdW0gb2YgYWxsIHRoZQovLyBzdWJzdHJpbmdzIG9mIGEgZ2l2ZW4gc3RyaW5nIHJlcHJlc2VudGluZyBhIG51bWJlcgojaW5jbHVkZSA8Yml0cy9zdGRjKysuaD4KdXNpbmcgbmFtZXNwYWNlIHN0ZDsKCnZvaWQgc3ViU3RyaW5nKHN0cmluZyBzLCBpbnQgbGVuZ3RoKXsKdmVjdG9yPGludD4gdjsKLy8gZmluZGluZyBhbGwgcG9zc2libGUgc3Vic3RyaW5ncwpmb3IgKGludCBpID0gMDsgaSA8IGxlbmd0aDsgaSsrKXsKZm9yIChpbnQgbGVuID0gMTsgbGVuIDw9IGxlbmd0aCAtIGk7IGxlbisrKXsKc3RyaW5nIHN1Yl9zdHIgPShzLnN1YnN0cihpLCBsZW4pKTsKaW50IHg9c3RvaShzdWJfc3RyKTsgLy8gY29udmVydGluZyB0byBpbnRlZ2VyIGZvcm1hdAp2LnB1c2hfYmFjayh4KTsvL2luc2VydGluZyBpbnRvIGEgdmVjdG9yCn0KfQpjb3V0PDwqbWluX2VsZW1lbnQodi5iZWdpbigpLHYuZW5kKCkpPDxlbmRsOwp9CgovLyBEcml2ZXIgcHJvZ3JhbSB0byB0ZXN0IGFib3ZlIGZ1bmN0aW9uCmludCBtYWluKCl7CgpzdHJpbmcgcyA9ICI5MzI4IjsKc3ViU3RyaW5nKHMsIHMubGVuZ3RoKCkpOwoKcmV0dXJuIDA7Cg==

Output

2

Explanation:

All substrings are { 9, 93, 932, 9328, 3, 32, 328, 2, 28, 8 }, and the minimum value substring is 2.

• We define the function subString(), which accepts two parameters: the string s and the length of the string.
• We then create a vector to store the substrings in integer format.
• Next, we use a set of nested for loops to calculate all possible substrings and convert them to integers, subsequently inserting this into a vector.
• We finally find the minimum element, which the function prints to the console using cout.
• In the main() function, we create a string, s, and call the subString() function to get the minimum value.

Maximum Value of all Substrings of a String Representing a Number

We have been given an integer represented as a string. Now our task is to get the maximum of all possible substrings of the given string, which is representing a number.

Example Code:

            // C++ program to find maximum of all possible substrings of given string
#include <bits/stdc++.h>
using namespace std;

void subString(string s, int length){
vector v;
// finding all possible substrings
for (int i = 0; i < length; i++){
for (int len = 1; len <= length - i; len++){
string sub_str =(s.substr(i, len));
int x=stoi(sub_str);// converting to integer format
v.push_back(x);//inserting into a vector
}
}
cout<<*max_element(v.begin(),v.end())<<endl;
}

// Driver program to test above function
int main(){

string s = "423";
subString(s, s.length());

return 0;
}
          

Ly8gQysrIHByb2dyYW0gdG8gZmluZCBtYXhpbXVtIG9mIGFsbCBwb3NzaWJsZSBzdWJzdHJpbmdzIG9mIGdpdmVuIHN0cmluZwojaW5jbHVkZSA8Yml0cy9zdGRjKysuaD4KdXNpbmcgbmFtZXNwYWNlIHN0ZDsKCnZvaWQgc3ViU3RyaW5nKHN0cmluZyBzLCBpbnQgbGVuZ3RoKXsKdmVjdG9yPGludD4gdjsKLy8gZmluZGluZyBhbGwgcG9zc2libGUgc3Vic3RyaW5ncwpmb3IgKGludCBpID0gMDsgaSA8IGxlbmd0aDsgaSsrKXsKZm9yIChpbnQgbGVuID0gMTsgbGVuIDw9IGxlbmd0aCAtIGk7IGxlbisrKXsKc3RyaW5nIHN1Yl9zdHIgPShzLnN1YnN0cihpLCBsZW4pKTsKaW50IHg9c3RvaShzdWJfc3RyKTsvLyBjb252ZXJ0aW5nIHRvIGludGVnZXIgZm9ybWF0CnYucHVzaF9iYWNrKHgpOy8vaW5zZXJ0aW5nIGludG8gYSB2ZWN0b3IKfQp9CmNvdXQ8PCptYXhfZWxlbWVudCh2LmJlZ2luKCksdi5lbmQoKSk8PGVuZGw7Cn0KCi8vIERyaXZlciBwcm9ncmFtIHRvIHRlc3QgYWJvdmUgZnVuY3Rpb24KaW50IG1haW4oKXsKCnN0cmluZyBzID0gIjQyMyI7CnN1YlN0cmluZyhzLCBzLmxlbmd0aCgpKTsKCnJldHVybiAwOwp9

Output

423

Explanation:

All substrings are { 4, 42, 423, 2, 23, 3 }, and the maximum value substring is 423.

• We define a function subString() that accepts two parameters: the string s and the length of the string. 
• Then, we create a vector to store the substrings in integer format.
• Next, we use a set of nested for loops to calculate all possible substrings and convert them to integers, subsequently inserting this into a vector.
• We finally find the maximum element using C++ STL.

Get Substring Before a Specific Character (With substr() and find())

A common requirement is to extract everything that comes after a delimiter within a string—such as getting the file extension, processing key-value pairs, or parsing URLs. You can do this easily by combining .find() and .substr().

Code Example:

            #include 
#include 
using namespace std;
int main() {
    string s = "dog:cat";
    // Find position of delimiter ':'
    size_t pos = s.find(':');
    // Extract everything before it
    string sub = s.substr(0, pos);
    cout << "Substring before ':' is: " << sub << endl;
    return 0;
}
          

I2luY2x1ZGUgPGlvc3RyZWFtPgojaW5jbHVkZSA8c3RyaW5nPgp1c2luZyBuYW1lc3BhY2Ugc3RkOwppbnQgbWFpbigpIHsKICAgIHN0cmluZyBzID0gImRvZzpjYXQiOwogICAgLy8gRmluZCBwb3NpdGlvbiBvZiBkZWxpbWl0ZXIgJzonCiAgICBzaXplX3QgcG9zID0gcy5maW5kKCc6Jyk7CiAgICAvLyBFeHRyYWN0IGV2ZXJ5dGhpbmcgYmVmb3JlIGl0CiAgICBzdHJpbmcgc3ViID0gcy5zdWJzdHIoMCwgcG9zKTsKICAgIGNvdXQgPDwgIlN1YnN0cmluZyBiZWZvcmUgJzonIGlzOiAiIDw8IHN1YiA8PCBlbmRsOwogICAgcmV0dXJuIDA7Cn0=

Output:

Substring before ':' is: dog

Explanation:

In this example,

1. We define a string s with the value “dog:cat”. 
2. Then, we use the find() function to get the index of a specific character, i.e., s.find(':') returns the index of ':' (here, 3).
3. Next, we use the substr() function, i.e., substr(0, pos), which extracts the string from index 0 up to, but does not include index 3.
4. We display this to the console using the cout statement, and the main function closes with a return 0 statement.

Points To Remember For Substr In C++

1. The index of the first character is always taken as 0 (not 1).
2. The starting_pos and substr_len parameters only accept unsigned integer numbers and no other data type.
3. If starting_pos equals (=) the original string length, the function returns an empty string.
4. If starting_pos is greater than (>) original string length, it throws an ‘out_of_range’ exception, and there are no changes in the string.
5. If substr_len is greater than (>) the size of the original string, then the returned sub-string is [starting_pos, size()).
6. If substr_len is not passed as a parameter, then the returned sub-string is [starting_pos, size()).

Conclusion

The C++ substr() function, part of the <string> class, is a powerful tool for extracting parts of a string. It takes two unsigned integer parameters: starting position and length. If the length goes beyond the end, it safely returns characters up to the string's end. However, if the starting position exceeds the string length, substr() throws a std::out_of_range exception—so always validate your inputs. In essence, substr() gives you flexible control over string slicing with predictable behavior when used correctly.

Frequently Asked Questions

Q1. What is a substr() in C++?

The substr() is a method of std::string (defined in <string>) that returns a new string. You specify a start index and length, and it slices that part from the original string. The substr function takes two arguments:

1. Starting_pos: Indicating the Position of the first character to be copied from the original string.
2. Substr_len: Indicates the desired length of the substring from the first position.

Here is the basic syntax of C++ substr() function:

string substr(starting_pos, len_substr)

Q2. How to get a substring of a string in CPP?

To get the substring of a string in CPP, you can use the substr() function. Here is an example:

            #include 
#include  // including string.h library
using namespace std;

int main() {

string originalString = "Substring";
string sub_string = originalString.substr(0,6);
// starting_pos = 0 and length = 6
// Implies it prints from index=0 to index=5 of the original string

cout << sub_string <<endl;

return 0;
}
          

I2luY2x1ZGUgPGlvc3RyZWFtPgojaW5jbHVkZSA8c3RyaW5nLmg+IC8vIGluY2x1ZGluZyBzdHJpbmcuaCBsaWJyYXJ5CnVzaW5nIG5hbWVzcGFjZSBzdGQ7CgppbnQgbWFpbigpIHsKCnN0cmluZyBvcmlnaW5hbFN0cmluZyA9ICJTdWJzdHJpbmciOwpzdHJpbmcgc3ViX3N0cmluZyA9IG9yaWdpbmFsU3RyaW5nLnN1YnN0cigwLDYpOwovLyBzdGFydGluZ19wb3MgPSAwIGFuZCBsZW5ndGggPSA2Ci8vIEltcGxpZXMgaXQgcHJpbnRzIGZyb20gaW5kZXg9MCB0byBpbmRleD01IG9mIHRoZSBvcmlnaW5hbCBzdHJpbmcKCmNvdXQgPDwgc3ViX3N0cmluZyA8PGVuZGw7CgpyZXR1cm4gMDsKfQ==

Output:

Substr

Q3. Do I need to include <string.h> for substr()?

No. Use the C++ string header:

#include <string>

Not the C header <string.h> (or <cstring>), which does not provide std::string.

Q4. Does substr() support negative values?

No. Both parameters are size_t (unsigned). Negative values lead to undefined behavior or compilation error.

Q5. Does substr() include the first character?

Yes. The substring starts exactly at the given index and includes that character, continuing for the specified len.

Q6. What if start equals or exceeds the string length?

• If start == str.size(): returns an empty string.
• If start > str.size(): throws a std::out_of_range exception

Q7. Can I remove part of a string using substr()?

Yes, you can use the substr() function in combination with erase() function to remove a part of the string. Example:

string s = "how are you?";
string del = s.substr(3, 4);  // "are "
s.erase(3, del.length());
cout << s;  // prints "how you?"

This trims a specified segment out of the string.

Test Your Skills: Quiz Time

You might also be interested in reading the following:

1. Pointers in C++ | A Roadmap To All Types Of Pointers With Examples
2. Decoding The Difference Between Structure And Class In C++
3. Typedef In C++ | Syntax, Application & How To Use It (With Examples)
4. C++ String Concatenation | All Methods Explained (With Examples)
5. String Compare In C++ | Learn To Compare Strings With Examples