Custom substring class help. Comparing elements of two substrinsg

[AndroidZ]

I'm working within the equals_to function. I'm trying to figure out how to compare the elements using a subscript, but I can't do something like other[pos]. Any hints are greatly appreciated.

substring.cpp

#include "substring.h"
#include <string>
#include <iostream>

// Constructor that takes a reference to a string:
substring::substring( std::string& str )
    :
    m_str(str),
    m_begin(0),
    m_end(str.length())
{
    /*
    The substring class is entirely dependent on the std::string object
    which has to be passed to each constructor. It will be refferred to
    as "underlying string object" in our comments.

    DONE: Add initializer list to this constructor, or your code won't
    compile.

    DONE: Add two member variables to accommodate the substring
    positions,

        size_t m_begin;  // absolute offset of the substring beginning
        size_t m_end;    // absolute offset of the substring ending

    and set these positions to match the entire string.
    */
}

// Constructor that takes string reference, beginning, and ending positions
substring::substring( std::string& str, size_t pos_begin, size_t pos_end )
    :
    m_str(str),
    m_begin(pos_begin),
    m_end(pos_end)
{
    /*
    In addition to std::string object, this constructor
    takes two absolute positions to initialize m_begin
    and m_end offsets of the substring object.

    DONE: Add initializer list to this constructor, or your code won't
    compile.
    */
}

// Return copy of the substring as std::string object
std::string substring::str() const
{
    /*
    This function returns a copy of the string object, initialized
    by the characters of the substring.

    DONE: modify the following statement to construct and return
    the appropriate string:
    */
    return m_str.substr(m_begin, size());
    //                  starting length
    //                  position
}

// Return substring size
size_t substring::size() const
{
    return m_end - m_begin;
}

// Return beginning position
size_t substring::begin() const
{
    return m_begin;
}

// Return ending position
size_t substring::end() const
{
    return m_end;
}

// Set beginning position
void substring::begin( size_t pos )
{
    m_begin = pos;
}

// Set ending position
void substring::end( size_t pos )
{
    m_end = pos;
}

// The string content is set to an empty string
void substring::clear()
{
    m_str.replace(m_begin, size(), "");
    m_end = m_begin;
}

// Replace substring with str
substring& substring::replace( std::string const& str )
{
    m_str.replace(m_begin, size(), str);
    m_end = m_begin + str.length();
    return *this;
}

// Fill substring with a particular character
substring& substring::fill( char ch )
{
        size_t pos = m_begin;
        for(; pos < m_end; ++pos){
             m_str[pos] = ch;
        }
    return *this;
}

// Insert str at the specified position:
substring& substring::insert( std::string const& str, size_t pos )
{
    /*
    Hint: use insert() member function of std::string.

    TODO: because insert causes changes in the underlying substring,
    the function must compare its beginning and ending against the
    insertion position and the length of the string being inserted.
    The substring needs to adjust its beginning and ending positions
    as demonstrated by the following diagrams:

    Example 1.
      BEFORE insert:

        insert( "abc", pos )
                        |
                     .--'
                     |
            m_str: XXXX?????????????????XXXXXXXXXX
                       |                |
                       '-m_begin        `-m_end

      AFTER insert:
                     |
            m_str: XXabcXX?????????????????XXXXXXXXXX
                          |                |
                          '-m_begin:       `-m_end:
                            got adjusted     got adjusted

    Example 2.
      BEFORE insert:

        insert( "abc", pos )
                        |
                        `-------.
                                |
            m_str: XXXX?????????????????XXXXXXXXXX
                       |                |
                       '-m_begin        `-m_end

      AFTER insert:
                                |
            m_str: XXXX?????????abc???????XXXXXXXXXX
                       |                  |
                       '-m_begin          `-m_end: got adjusted


    IMPORTANT: Make your own decision regarding two special cases
    when the insertion occurs exactly at the beginning, or exactly
    at the ending of the substring. Make sure to document your
    coding in the comments of your program.
    */
    std::cout << "end pos: " << m_end << '\n';//debug
    std::cout << "beg pos: " << m_begin << '\n';//debug

    m_str.insert(pos, str);

    if (pos < m_begin){
        m_begin += str.length();
        m_end += str.length();
        std::cout << "pos < m_begin \n";//db
    }
    else if (pos > m_begin && pos < m_end){
        m_end += str.length();
        std::cout << "pos > m_begin AND  < m_end \n";//db
    }
    else if (pos == m_begin){
        m_end += str.length();
        //assuming the user wants the inserted string to be the beginning
        std::cout << "pos == m_begin \n";//db
    }
    else if (pos == m_end){
        //assuming the user wants the inserted string to be the end
        m_end += str.length();
        std::cout << "pos == m_end \n";//db
    }

    std::cout << "end pos: " << m_end << '\n';//debug
    std::cout << "beg pos: " << m_begin << '\n';//debug

    return *this;
}

// Convert substring to UPPER CASE
substring& substring::toupper()
{
    size_t pos = m_begin;
        for(; pos < m_end; ++pos){
             m_str[pos] = std::toupper(m_str[pos]);
        }
    return *this;
}

// Convert substring to lower case
substring& substring::tolower()
{
    size_t pos = m_begin;
        for(; pos < m_end; ++pos){
             m_str[pos] = std::tolower(m_str[pos]);
        }
    return *this;
}

// Search for a new substring starting at the specified position:
size_t substring::search( const std::string& str, size_t pos )
{
    /*
    DONE: use find() of the underlying string and update the beginning
    and the ending positions of the substring.

    DONE: when find() call fails, it returns back the member value
    std::string::npos. In such case the substring must not update
    its positions and also return std::string::npos back to the caller:
    */
    size_t result = result = m_str.find(str, pos);
    if (result != std::string::npos){
        m_begin = result;
        m_end = m_begin + str.length();
        return result;
    }
    else{
        return std::string::npos;
    }
}

// The string content is set to the size of entire string
void substring::expand()
{
    /*
    DONE: Update substring positions to match the entire
    underlying string.
    */
    m_begin = 0;
    m_end = m_str.length();
}

// Equality test between two substrings
bool substring::equals_to( substring const& other ) const
{
    /*
    TODO: Compare this substring with another character by character.
    The test should succeed if every character in both substrings
    matches exactly.

    Return true, if the underlying text fragments are the same.
    Return false otherwise.
    */
    size_t pos = m_begin;

    return false;
}

[AndroidZ]

substring.h

// CIS-62 substring class

#ifndef _CIS62_SUBSTRING_H_INCLUDED_
#define _CIS62_SUBSTRING_H_INCLUDED_

#include <string>

class substring {
    std::string& m_str;
    size_t m_begin;  // absolute offset of the substring beginning
    size_t m_end;    // absolute offset of the substring ending
public:
    // Constructor that takes a reference to a string:
    substring( std::string& str );

    // Constructor that takes string reference, beginning, and ending positions
    substring( std::string& str, size_t pos_begin, size_t pos_end );

    // Return copy of the substring as std::string object
    std::string str() const;

    // Return substring size
    size_t size() const;

    // Return beginning position
    size_t begin() const;

    // Return ending position
    size_t end() const;

    // Set beginning position
    void begin( size_t pos );

    // Set ending position
    void end( size_t pos );

    // The string content is set to an empty string
    void clear();

    // Replace substring with str
    substring& replace( std::string const& str );

    // Fill substring with a particular character
    substring& fill( char ch );

    // Insert str at the specified position:
    substring& insert( std::string const& str, size_t pos );

    // Convert substring to UPPER CASE
    substring& toupper();

    // Convert substring to lower case
    substring& tolower();

    // Search for a new substring starting at the specified position:
    size_t search( const std::string& str, size_t pos );

    // The string content is set to the size of entire string
    void expand();

    // Equality test between two substrings
    bool equals_to( substring const& other ) const;

    // Equality test between substring and std::string
    bool equals_to( std::string const& str ) const;

    // Merge with another substring
    substring& merge( substring const& other );

    // Swap with another substring
    void swap( substring& other );

    // Prepare substring for parsing
    substring& parse();

    // Test if substring is alphabetic
    substring& isalpha();

    // Test if substring is upper case
    substring& isupper();

    // Test if substring is lower case
    substring& islower();

    // Test if substring is digit
    substring& isdigit();

    // Test if substring is alphabetic or digit
    substring& isalnum();

    // Test if substring is blank, tab, newline, return, formfeed, or vertical tab
    substring& isspace();

    // Test if substring is matches text specified by str
    substring& isstr( const std::string& str );

    // Test if substring is empty
    substring& isempty();

    // Return beginning position
    bool succeeded() const;

    // Return matching substring
    substring match() const;

    // Undo changes caused by parsing
    substring& unparse();
};

#endif // _CIS62_SUBSTRING_H_INCLUDED_ 

substring_main.cpp

// main driver sample to test substring functionality.

#include <cassert>
#include <iostream>
#include "substring.h"

int main()
{
    //\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//
    // Test basic substring functionality
    //\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//
    std::string str( "abc" );
    substring sub( str );

    std::cout << '\n' << sub.str() << '\n';//DEBUG

    assert( sub.str() == "abc" );
    assert( sub.begin() == 0 );
    assert( sub.end() == 3 );
    assert( sub.end() == sub.size() );

    sub.begin( 1 ); // reposition absolute offsets
    sub.end( 2 );
    assert( sub.str() == "b" );

    std::cout << '\n' << sub.str() << '\n';//DEBUG

    sub.replace( "HELLO" );
    assert( sub.str() == "HELLO" );
    assert( str == "aHELLOc" );
    assert( sub.begin() == 1 );
    assert( sub.end() == 6 );
    assert( sub.size() == 5 );

    sub.clear();
    assert( sub.str() == "" );
    assert( str == "ac" );
    assert( sub.begin() == 1 );
    assert( sub.end() == 1 );
    assert( sub.size() == 0 );

    sub.insert( "XYZ", sub.begin() );
    assert( str == "aXYZc" );

    sub.expand();
    assert( str == "aXYZc" );
    assert( sub.begin() == 0 );
    assert( sub.end() == str.size() );

    size_t result = sub.search( "YZc", sub.end() );
    assert( result == std::string::npos );

    result = sub.search( "YZc", sub.begin() );
    assert( result == 2 );
    assert( sub.begin() == 2 );
    assert( sub.end() == str.size() );
    assert( sub.size() == 3 );

    sub.fill( '?' );
    assert( sub.begin() == 2 );
    assert( sub.end() == str.size() );
    assert( sub.equals_to( "???" ) );
    assert( str == "aX???" );

    sub.expand();
    sub.toupper();
    assert( sub.equals_to( "AX???" ) );
    assert( str == "AX???" );

    sub.tolower();
    assert( sub.equals_to( "ax???" ) );
    assert( str == "ax???" );

    substring sub2 = sub; // invokes copy constructor
    result = sub2.search( "x?", sub.begin() );
    assert( sub2.equals_to( "x?" ) );
    assert( sub.equals_to( "ax???" ) );

    sub2.merge( sub );
    assert( sub2.equals_to( "ax???" ) );
    assert( sub.equals_to( sub2 ) );

    //\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//
    // Parsing tests
    //\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//
    str = "ABC123abc ";
    sub.expand();
    if ( sub.parse().isalpha().isdigit().isalnum().isspace().isempty().succeeded() ) {
        sub.match().replace( "xyz" );
        assert( str == "xyz" );
    } else {
        sub.unparse(); // restore the original substring
    }

    return 0;
}

[Peter87]

You can use std::string::compare to compare parts of strings.

Another way is to first check if both substrings are of the same length and return false if they are not. If they have the same length you just use a loop and check each character and return false if you find a mismatch. After the loop you return true because then you know the strings are equal.

[AndroidZ]

Can someone tell me where I'm going wrong here?

bool substring::equals_to( substring const& other ) const
{
    /*
    TODO: Compare this substring with another character by character.
    The test should succeed if every character in both substrings
    matches exactly.

    Return true, if the underlying text fragments are the same.
    Return false otherwise.
    */
    size_t pos = m_begin;
    size_t end = pos + other.m_str.length();

    if (m_str.length() == other.m_str.length()){
        std::cout << "Equal Lengths";
        for (; pos < m_end; pos++){
            if (m_str[pos] != other.m_str[pos]){
                return false;
            }
            if (m_str[pos] == other.m_str[pos]){
                if (pos == end){
                    return true;
                }
            }
        }
    }
    else{
        return false;
    }
    
    //return false;
}

[Peter87]

It's not the length of the string you are interested in. It's the length of the substring.

[AndroidZ]

Updated, but still not working.

// Equality test between two substrings
bool substring::equals_to( substring const& other ) const
{
    /*
    TODO: Compare this substring with another character by character.
    The test should succeed if every character in both substrings
    matches exactly.

    Return true, if the underlying text fragments are the same.
    Return false otherwise.
    */
    size_t pos = m_begin;
    size_t end = pos + other.m_str.length();
    size_t length = m_str.length() - m_begin;
    
    if (length == other.m_str.length()){
        std::cout << "Equal Lengths";
        for (; pos < m_end; pos++){
            if (m_str[pos] != other.m_str[pos]){
                return false;
            }
            if (m_str[pos] == other.m_str[pos]){
                if (pos == end){
                    return true;
                }
            }
        }
    }
    else{
        return false;
    }
}

[Peter87]

You can't use pos to index both strings because they might have different m_begin.

substring has a member function called size() that gives you the length of the substring. Use it!

[AndroidZ]

... still

// Equality test between two substrings
bool substring::equals_to( substring const& other ) const
{
    /*
    TODO: Compare this substring with another character by character.
    The test should succeed if every character in both substrings
    matches exactly.

    Return true, if the underlying text fragments are the same.
    Return false otherwise.
    */
    size_t pos = m_begin;
    size_t i = 0;

    if ( m_str.size() == other.m_str.length()){
        std::cout << "Equal Lengths";
        for (; pos < m_end; pos++){
            if (m_str[pos] != other.m_str[i]){
                return false;
            }
            i++;
            if (m_str[pos] == other.m_str[i] && pos == m_end){
                return true;
            }
        }
    }
    else{
        return false;
    }
}

[AndroidZ]

How do I access the substring? Do I use a this pointer?

[Cubbi]

C++ comes with a lot of useful functions, in this case, std::equal() fits the bill just right:

bool substring::equals_to( std::string const& other ) const
{
    return other.size() == size() &&
           std::equal(other.begin(), other.end(), m_str.begin() + m_begin);
}

bool substring::equals_to( substring const& other ) const
{
    return other.size() == size() &&
           std::equal(m_str.begin() + m_begin,
                      m_str.begin() + m_end,
                      other.m_str.begin() + other.m_begin);
}

By the way, don't forget to fix that " result = result =" in line 232

[AndroidZ]

The assertion on line 62 in main is still failing after I implement your version. Also, I think I'm technically supposed to do this by comparing character by character, as the description says, but I'm going to look up the std::equal() function to better understand what you wrote.

[Cubbi]

Works for me, with the calls to non-existent functions commented out:

~ $ ./test

abc

b
end pos: 1
beg pos: 1
pos == m_begin 
end pos: 4
beg pos: 1
test: test.cc:80: int main(): Assertion `sub2.equals_to( "ax???" )' failed.

(the last one is after the non-existent merge())

[AndroidZ]

Thanks, but I'm don't feel right just copying your code. I need to do it character by character anyway. Can anyone provide further help with that? Really lost here.