C++ Tutorials - Absolute n00b spoonfeed

I made these functions because the string class doesn't provide these and the standard functions only convert a single char. I thought they might be helpful since they prevent the extra function call that's needed when using tolower/toupper from cctype.

Code: Select all

void toUpper(string &str)
{
   for (unsigned int i = 0; str[i] != '\0'; ++i)
   {
     if (str[i] > 0x60 && str[i] < 0x7b)
          str[i] &= 0xdf;
   }
}

void toLower(string &str)
{
   for (unsigned int i = 0; str[i] != '\0'; ++i)
   {
     if (str[i] > 0x40 && str[i] < 0x5b)
          str[i] |= 0x20;
   }
}



Using by reference is the preferred way, but you can use pointers to if you have to.

Code: Select all

void toUpper(string *str)
{
   for (unsigned int i = 0; str->operator[](i) != '\0'; ++i)
   {
     if (str->operator[](i) > 0x60 && str->operator[](i) < 0x7b)
          str->operator[](i) &= 0xdf;
   }
}

void toLower(string *str)
{
   for (unsigned int i = 0; str->operator[](i) != '\0'; ++i)
   {
     if (str->operator[](i) > 0x40 && str->operator[](i) < 0x5b)
          str->operator[](i) |= 0x20;
   }
}


Cool.

Another way of doing

Code: Select all

str->operator[](i)

is

Code: Select all

(*str)[i]

Looks like your technique depends entirely on the layout of the ASCII code page. Some may argue that that is not the best way of doing it, but instead one should use more platform specific APIs to do things like this.

That's true
I decided they might be useful because most people use either Windows or Linux anyway. I just wanted to have a fast way of doing the conversion without extra function calling. To make things even easier I made a custom String class to implement the case methods. It also provides string array indexing with bounds checking. It's derived from the std::string class so it also has all basic string operations. Since std:string is not a polymorphic class you can't use polymorphic features for the custom String class, since that can lead to undefined behavior. With polymorphic I mean you can't use a base class pointer to reference the String object. Doing so can result in strange things happening when the wrong destructor gets called. You don't need polymorphic features anyway for this to be useful.

To use it all you have to do is include String.h in your program.

Code: Select all

// String.h

#pragma once

#include <string>
#include "Bounds.h"


class String : public std::string
{
    size_t length;
public:
    String(const std::string &);
    String(const char *);
    String();
    ~String();
    String & operator=(const std::string &);
    String & operator=(const char *);
    const char & operator[](const size_t) throw(Bounds);
    const String & operator>>(std::string &);
    void toUpper();
    void toLower();
};


Code: Select all

// String.cpp

#include "String.h"

using std::string;


String::String(const string &str) : string(str), length(size())
{
}

String::String(const char *str) : string(str), length(size())
{
}

String::String() : length(0)
{
}

String::~String()
{
}

String & String::operator=(const string &str)
{
    assign(str);
    length = size();
    return *this;
}

String & String::operator=(const char *str)
{
    assign(str);
    length = size();
    return *this;
}

const char & String::operator[](const size_t index) throw(Bounds)
{
    if (index >= length)
        throw Bounds("Out of bounds error.");
    return *(data() + index);
}

const String & String::operator>>(string &str)
{
    str.assign(data());
    return *this;
}

void String::toUpper()
{
    for (unsigned int i = 0; i < length; ++i)
    {
        if (at(i) > 0x60 && at(i) < 0x7b)
            at(i) &= 0xdf;
    }
}

void String::toLower()
{
    for (unsigned int i = 0; i < length; ++i)
    {
        if (at(i) > 0x40 && at(i) < 0x5b)
            at(i) |= 0x20;
    }
}


Code: Select all

// Bounds.h

#pragma once

#include <exception>


class String;

class Bounds : public std::exception
{
    String *const str;
    virtual const char * what() const throw();
public:
    Bounds(const char *);
    Bounds(const String &);
    Bounds();
    virtual ~Bounds() throw();
};


Code: Select all

// Bounds.cpp

#include "Bounds.h"
#include "String.h"


const char * Bounds::what() const throw()
{
    return str->data();
}

Bounds::Bounds(const char *_str) : str(new String(_str))
{
}

Bounds::Bounds(const String &_str) : str(new String(_str))
{
}

Bounds::~Bounds() throw()
{
    delete str;
}


careful not to cause header-file name ambiguities, as a "string.h" file does exist amongst the standard C headers.

antiRTFM wrote:careful not to cause header-file name ambiguities, as a "string.h" file does exist amongst the standard C headers.

Frankly, I don't see how that could be a problem. If you include it with the "" then the compiler will look for the header file in the current directory. It would be a problem if you include it using <> as well, or put the custom header in the include path of the compiler. Linux does not have these issues to begin with, since file names are case sensitive.

Boy do I hate operator overlods O_O. Aswell as pointers. I understand them and how they work, but using them can sometimes get deep and confusing.

Why aren't you using the STL?

Example:

Code: Select all

#include <algorithm>
#include <string>

std::string Test("Hello World");
std::transform(Test.begin(), Test.end(), Test.begin(), tolower);


The above converts the string to lowercase, Simple replace tolower with toupper for uppercase