KTurley.com

This little piece of code can convert a string of decimal characters into an integer value.  If you seek to convert a string into a double, see this post.

/*
 * A function to convert a string into an integer
 */

#include <string>

int StringToInt (std::string str)
{
    int total = 0;
    int length = str.length(); // the length of the string
    int x = 1; // this is our multiplier, used to convert each digit into tens, units, etc
    for (int i = 1; i < str.length(); i++)
        x *= 10; // initialise x correctly

    for (int i = 0; i < length; i++)
    { // loop through the string
        // 48 is the base value (ASCII)
        // multiply it by x to get it into tens, units, etc
        total += (static_cast <int> (str[i]) - 48) * x;
        x /= 10; // divide x by 10, to reduce the units by one
    }

    return total; // return the value as an integer
}

/** EXAMPLE USAGE **/
#include <iostream>
int main ()
{
    int t = StringToInt("1234") + 300;
    std::cout < < t; // should be 1534 (1234 + 300 = 1534)

    std::cin.get ();
    return EXIT_SUCCESS;
}

This C++ class is a good demonstration of Object Orientation in code.

Download the  entire code: RadioClass.zip

// definition file for class Radio
#ifndef RADIO_H
#define RADIO_H
#include <iostream>
using namespace std;

const bool FM = true;
const bool AM = false;
const bool ON = true;
const bool OFF = false;
const int MIN_VOLUME = 0;
const int MAX_VOLUME = 11; // it goes to eleven!

class Radio
{
public:
	// constructors:
	Radio();
	Radio(bool b,bool p,double fm,double am,int v);

	// accessors:
	bool getBand();
	bool getPower();
	double getFMStation();
	double getAMStation();
	int getVolume();

	// mutators:
	bool setBand(bool b);
	bool setPower(bool p);
	bool setFMStation(double s);
	bool setAMStation(double s);
	bool setVolume(int v);

	// utility functions:
	void displayRadio();

private:
	bool band; // FM = true, AM = false
	bool power; // on = true, off = false
	double FMstation , AMstation ; // as per norms
	int volume; // 0..11 is the valid range
};
#endif

// Implementation file for class Radio
#include <iostream>
#include "Radio.h"
using namespace std;

// constructors:
Radio::Radio()
{
	band = FM;
	volume = 4;
	power = OFF;
	FMstation = 88.1;
	AMstation = 530;
}

bool Radio::setFMStation(double s)
{
	if((s < 88.1) || (s > 107.9))  // Station's input out of range
		return false;
	if((int(s * 10) % 2) == 0)     // station's .x is even and therefore invalid
		return false;
	FMstation = s;
	return true;
}
bool Radio::setAMStation(double s)
{
	if((s &lt; 530) || (s &gt; 1600))
		return false;
	if((int(s) % 10) != 0) // AMstation not divisible by 10 and therefore invalid
		return false;
	AMstation = s;
	return true;
}

// utility functions:
void Radio::displayRadio()
{
	cout << "Band = " <<; ((band == FM) ? "FM":"AM") << endl;
	cout &lt;&lt; "Power = " &lt;&lt; ((power == ON) ? "ON":"OFF") &lt;&lt; endl;
	cout &lt;&lt; "FM Station = " &lt;&lt; FMstation &lt;&lt; endl;
	cout &lt;&lt; "AM Station = " &lt;&lt; AMstation &lt;&lt; endl;
	cout &lt;&lt; "Volume = " &lt;&lt; volume &lt;&lt; endl &lt;&lt; endl;
}

// mutators:
bool Radio::setBand(bool b)
{
	band = b;
	return true;
}
bool Radio::setPower(bool p)
{
	power = p;
	return true;
}
bool Radio::setVolume(int v)
{
	if((v < MIN_VOLUME) || (v > MAX_VOLUME))
		return false;
	volume = v;
	return true;
}
//custom constructor , placed later on purpose.
Radio::Radio(bool b,bool p,double fm,double am,int v) // build a radio with custom defaults
{
	band = FM;
	setBand(b);
	power = OFF;
	setPower(p);
	FMstation = 88.1;
	setFMStation(fm);
	AMstation = 530;
	setAMStation(am);
	volume = 4;
	setVolume(v);
}
// accessors:
bool Radio::getBand()
{
	return band;
}
bool Radio::getPower()
{
	return power;
}
double Radio::getFMStation()
{
	return FMstation;
}
double Radio::getAMStation()
{
	return AMstation;
}
int Radio::getVolume()
{
	return volume;
}

// Driver file for class Radio
#include <iostream>
#include "Radio.h"
using namespace std;

//Radio object driver, this file sends the commands that "push the radio buttons" via function calls.

void main()
{
	Radio myJamBox;              // Build a radio to be referred to as 'myJamBox'.

	myJamBox.displayRadio();     // display myJamBox's current attributes.
	myJamBox.setAMStation(550);  // adjust's myJamBox's AM station to 530
	myJamBox.setPower(ON);       // flips myJamBox's power swith ON
	myJamBox.displayRadio();     // display myJamBox's current attributes.

	system("pause");

}

Definition file, stack.h

#ifndef STACK_H
#define STACK_H

#include <string>
using namespace std;

typedef string ItemType; // Change the datatype of the stack here

//-------------------------------------------------------------------------
// Class: Stack
// Class implements a doubly linked list of string items.
//-------------------------------------------------------------------------
class Stack
{
private:
	class Node;
	typedef Node* NodePtr;

	//-------------------------------------------------------------------------
	// Class: Node
	// A doubly linked list node.
	//-------------------------------------------------------------------------
	class Node
	{
	public:
		ItemType item;
		NodePtr previous;
		NodePtr next;

		Node(const ItemType& Item,
			 const NodePtr Previous,
			 const NodePtr Next)
		{
			item = Item;
			previous = Previous;
			next = Next;
		}
	};

	NodePtr head;

	// Deletes all the nodes on the list.  Head is set to NULL.
	void DeleteNodes();

	// Deep copies each node in the parameter linked list.
	void CopyNodes(NodePtr CopyHead);

	// Returns a node populated with supplied parameters
	NodePtr NewNode(const ItemType& Item,
				    const NodePtr Previous,
					const NodePtr Next);

public:
	// Sets the head to NULL.
	Stack() : head(NULL) {}

	// Makes a deep copy of the parameter stack.
	Stack(const Stack& CopyStack);

	// Destroys the entire list.
	~Stack();

	// Returns true if list is empty, false otherwise.
	bool IsEmpty() const { return (head == NULL); }

	// Returns the item at the top of the stack.
	ItemType TopItem() const { return (head->item); }

	// Inserts a new node containing Value at the front of the list.
	void Push(const ItemType& Value);

	// Removes the first item from the list.
	void Pop();

	// Makes deep copy of the rhs stack.
	Stack operator =(const Stack& rhs);
};

#endif

Implementation file, stack.cpp

#include "stack.h"
#include <stdexcept>
#include <iostream>

using namespace std;

// Deletes all the nodes on the list.  Head is set to NULL.
void Stack::DeleteNodes()
{
	NodePtr pDel = head;

	while (head != NULL)
	{
		head = head->next;
		pDel->previous = pDel->next = NULL;
		delete pDel;
		pDel = head;
	}
}

// Deep copies each node in the parameter linked list.
void Stack::CopyNodes(NodePtr CopyHead)
{
	NodePtr pTail;
	head = pTail = NewNode(CopyHead->item, NULL, NULL);
	CopyHead = CopyHead->next;

	while(CopyHead != NULL)
	{
		pTail = pTail->next = NewNode(CopyHead->item, pTail, NULL);
		CopyHead = CopyHead->next;
	}
	pTail = NULL;
}

// Returns a node populated with supplied parameters
Stack::NodePtr Stack::NewNode(const ItemType& Item,
			  	              const NodePtr Previous,
					          const NodePtr Next)
{
	NodePtr pNew;
	try
	{
		pNew = new Node(Item, Previous, Next);

		if (pNew == NULL) throw bad_alloc("Unable to allocate memory.");
	}
	catch (bad_alloc e)
	{
		cerr < < e.what() << endl;
	}
	return (pNew);
}

// Makes a deep copy of the parameter stack.
Stack::Stack(const Stack& CopyStack)
{
	CopyNodes(CopyStack.head);
}

// Destroys the entire list.
Stack::~Stack()
{
	DeleteNodes();
}

// Inserts a new node containing Value at the front of the list.
void Stack::Push(const ItemType& Value)
{
	if (head == NULL)
	{
		head = NewNode(Value, NULL, NULL);
	}
	else
	{
		head = head->previous = NewNode(Value, NULL, head);
	}
}

// Removes the first list from the list.
void Stack::Pop()
{
	NodePtr pDel = head;
	head = head->next;
	pDel->previous = pDel->next = NULL;
	delete pDel;
	pDel = NULL;
}

// Makes deep copy of the rhs stack.
Stack Stack::operator =(const Stack& rhs)
{
	if (this != &rhs)
	{
		DeleteNodes();
		CopyNodes(rhs.head);
	}
	return (*this);
}

Test driver

//-----------------------------------------------------------------------
// Name: Kyle Turley
//
// Date: Feb 5 2010
//
// Description: A doubly linked stack class driver
//-----------------------------------------------------------------------
#include "stack.h"
#include <iostream>

using namespace std;

void main()
{
	Stack EmptyStack;

	cout < < (EmptyStack.IsEmpty()? "Stack is empty." : "Stack is not empty.") << endl;

	Stack stack1;

	stack1.Push("Hello");
	stack1.Push("There");

	cout << stack1.TopItem() << endl << endl;

	Stack stack2(stack1);
	stack2.Pop();
	cout << "Stack1 top item: " << stack1.TopItem() << endl
		 << "Stack2 top item: " << stack2.TopItem() << endl
		 << endl;

	Stack stack3;
	stack3 = stack1;
	stack3.Push("NoWay");

	cout << "Stack1 top item: " << stack1.TopItem() << endl
		 << "Stack3 top item: " << stack3.TopItem() << endl
		 << endl;
}