WTF con't

Wow, kinda boggled by my first C++ program:

Code:

---

#include <iostream>
#include <string>
using namespace std;

class nlist : public string {
        public:
                nlist(string in) {
                        assign(in);
                }
                int extract(size_t *pos) {
                        int retv = 0, m = 1;
                        size_t end, place;
                        while (at(*pos) < '0'|| at(*pos) > '9') {
//                                printf("%d %d\n",*pos,at(*pos)); fflush(stdout);
                                (*pos)++;
                        }
                        end = *pos;
                        while (at(end) > '0'&& at(end) < '9') end++;
                        place = end;
                        end--;
                        while (end>=*pos) {
                                if (end<0) break;
        printf("pos %d end %d\n",*pos, end); fflush(stdout);
                                retv += (at(end--)-48)*m;
                                m*=10;
                        }
                        *pos = place;
                        return retv;
                }
};

int main() {
        string src="1,44,56,33\n";
        nlist nums(src);
        size_t len = nums.size(), pos = 0;

        cout << nums;
        while (pos<len) cout << nums.extract(&pos);

        return 0;
}

---

Considering the conditions in red, how is it possible that I get this at runtime:

1,44,56,33
pos 0 end 0
pos 0 end -1
terminate called after throwing an instance of 'std::out_of_range'
what(): basic_string::at
Aborted

"If (end<0) break;" then it proceeds to the next line and reports end = -1.
???????????????

Maybe the problem lies here, considering that there is no bounds checking other than the use of at():

Code:

---

while (at(*pos) < '0'|| at(*pos) > '9') {
    (*pos)++;
}

---

Again, please stop publicly inheriting from std::string. I know that inheritance is a novelty for you right now, but it is better that you do not start developing bad habits.

Your first C++ program? Really? With the comparison statements you've made before?

First of all, size_t is unsigned, hence the name (negative size?).

Second what laserlight said, don't inherit std::string (or most of the standard implementation besides streams and such for that matter).

Quote:

---

Originally Posted by laserlight

Maybe the problem lies here, considering that there is no bounds checking other than the use of at():

---

Nope. It's because end is -1:

Code:

---

                        while (end>=*pos) {
                                if (end<0) break;
        printf("pos %d end %d\n",*pos, end); fflush(stdout);   

---

Again, the output:
pos 0 end 0
pos 0 end -1
I do not understand how a loop which has that condition and that break would continue iterating. It should not be possible for that printf to execute while end < 0.

Okay, I guessing it's because size_t is an unsigned type....:p

Vis, deriving from std::string, yes, I understand this not a wise design move, I'm not planning on using it for anything except getting a feel for the syntax.

Quote:

---

Originally Posted by MK27

Okay, I guessing it's because size_t is an unsigned type....:p

---

Yep. Man, this C++ is weird. :p

Quote:

---

Originally Posted by MK27

Man, this C++ is weird.

---

size_t is inherited from C.

This is how I might implement the algorithm you have in mind with the kind of usage that you have in mind:

Code:

---

#include <iostream>
#include <string>

/* Extracts next integer in str starting from pos and assigns it to result.
 * Returns the position of the first unprocessed character or std::string::npos
 * if there there are no more integers left to process.
 */
std::string::size_type
extract(const std::string& str, std::string::size_type pos, int& result);

int main()
{
    std::string::size_type pos = 0;
    int num;
    while ((pos = extract("1,44,56,33\n", pos, num)) != std::string::npos)
    {
        std::cout << num << '\n';
    }
    std::cout.flush();
}

std::string::size_type
extract(const std::string& str, std::string::size_type pos, int& result)
{
    const std::string::size_type size = str.size();

    // Skip non-digit characters.
    for (; pos < size && (str[pos] < '0' || str[pos] > '9'); ++pos)
    {
        // Nothing to do here.
    }

    // Find last character of integer to be extracted.
    std::string::size_type end_pos = pos;
    for (; end_pos < size && (str[end_pos] >= '0' && str[end_pos] <= '9'); ++end_pos)
    {
        // Nothing to do here.
    }

    if (pos < end_pos)
    {
        // Extract integer portion into an int.
        result = 0;
        int multiplier = 1;
        for (std::string::size_type i = end_pos; i > pos;)
        {
            result += multiplier * (str[--i] - '0');
            multiplier *= 10;
        }
        return end_pos;
    }
    else
    {
        // Integer not found.
        return std::string::npos;
    }
}

---

That said, I realised that if we do not follow your algorithm so exactly, we can simplify, e.g.,

Code:

---

std::string::size_type
extract(const std::string& str, std::string::size_type pos, int& result)
{
    static const char* const digits = "0123456789";

    pos = str.find_first_of(digits, pos);

    if (pos == std::string::npos)
    {
        return std::string::npos; // Integer not found.
    }

    // Find one past the last character of non-negative integer to be extracted.
    std::string::size_type end_pos = str.find_first_not_of(digits, pos);
    if (end_pos == std::string::npos)
    {
        end_pos = str.size();
    }

    // Extract non-negative integer value into an int.
    result = 0;
    int multiplier = 1;
    for (std::string::size_type i = end_pos; i > pos;)
    {
        result += multiplier * (str[--i] - '0');
        multiplier *= 10;
    }
    return end_pos;
}

---

I guess I have to get on reading that book. Quick question(s):

1) so std::string::size_type is implementation specific, or always size_t?

Anyway thanks for that. I actually didn't scroll down far enough to notice stuff like "find_first_not_of". std::string, pretty neat.

Quote:

---

Originally Posted by MK27

1) so std::string::size_type is implementation specific, or always size_t?

---

std::string is a typedef for std::basic_string<char>, which has a default third template argument of std::allocator<char>. Now, the size_type member for std::basic_string is a typedef for the size_type member of this allocator. Since std::allocator<char>::size_type is a typedef for std::size_t, std::string::size_type is thus an alias for std::size_t.

Quote:

---

Originally Posted by MK27

I actually didn't scroll down far enough to notice stuff like "find_first_not_of". std::string, pretty neat.

---

Yeah, though it is a little less efficient than checking than comparing with '0' and '9'. A generic algorithm with a predicate could be used to get around that, but then writing a predicate currently often requires more boilerplate than is desirable, at least without the use of say Boost.Lamdba and such.

Quote:

---

Yeah, though it is a little less [...] of say Boost.Lamdba and such.

---

You could also go the other direction.

Still a lot of work. (NNR)

Soma

Code:

---

#include <algorithm>
#include <iostream>
#include <iterator>
#include <sstream>
#include <string>
#include <vector>

// a sortof `meta-function' to provide a default delmiter value
// based on the types used in the operation and
// the specializations needed for the standard streams

template
<
        typename T
>
struct delimiter
{
        static T get();
};

template <> struct delimiter<char>
{
        static char get()
        {
                return(',');
        }
};

template <> struct delimiter<wchar_t>
{
        static wchar_t get()
        {
                return(L',');
        }
};

// a `meta-function' to work around a few broken compilers
// and a few problematic `iterator_traits' implementation
// issues so we can properly determine the type to be
// stored

// works because the nested `value_type' of
// unspecialized `std::iterator_traits' should
// always be `void'

template
<
        typename itT,
        typename typeT
>
struct discover_nested_type2
{
        typedef typeT type;
};

template
<
        typename itT
>
struct discover_nested_type2<itT, void>
{
        typedef typename itT::container_type::value_type type;
};

// the interface to the above `meta-function'

template
<
        typename itT
>
struct discover_nested_type
{
        typedef typename std::iterator_traits<itT>::value_type maybe_value_type;
        typedef typename discover_nested_type2<itT, maybe_value_type>::type type;
};

// a function to "parse" delimted strings
// ignores quoted values and quoted value pairs

template
<
        typename inputT,
        typename outputT
>
void process
(
        inputT begin, // expects a `char *',
        inputT end,  // `wchar_t *', or compatible
        outputT out,  // expects an "input iterator" of some kind (including trivial pointer types)
        typename std::iterator_traits<inputT>::value_type delim = delimiter<typename std::iterator_traits<inputT>::value_type>::get()
)
{
        using namespace std;
        typedef typename iterator_traits<inputT>::value_type char_type;
        typedef typename discover_nested_type<outputT>::type value_type;
        basic_string<char_type> temp(begin, end);
        basic_istringstream<char_type> input(temp);
        while(getline(input, temp, delim))
        {
                value_type data;
                basic_istringstream<char_type> tin(temp);
                if(tin >> data)
                {
                        *out++ = data;
                }
                else
                {
                        throw("something");
                }
        }
}

int main()
{
        using namespace std;
        string test1("1.1,2.2,3.3,4.4");
        vector<double> data1;
        process(test1.begin(), test1.end(), back_inserter(data1));
        cout << "number of elements (1): " << data1.size() << '\n';
        copy(data1.begin(), data1.end(), ostream_iterator<double>(cout, "\n"));
        char test2[] = "-5&6&-7&8&9";
        int sizeof_test2(sizeof(test2)/sizeof(test2[0]));
        int data2[5];
        int sizeof_data2(sizeof(data2)/sizeof(data2[0]));
        process(test2, test2 + sizeof_test2, data2, '&');
        cout << "\nnumber of elements (2): " << 5 << '\n';
        copy(data2, data2 + sizeof_data2, ostream_iterator<int>(cout, "\n"));
        return(0);
}

---