Reverse a string by using unique pointer c++ - c++

Question

Below are my .cpp file and .h file. After getting a lot of help from Mike, I finally get it working; however, when I compile it on Visual Studio 2012, it gives me 2 warnings about '<' signed/unsigned mismatch right on the line "for (int i = 0; i < s.length(); i++)". Can anyone tell me what I did wrong in there ?
[code]
#include"DownwardStack.h"
#include<iostream>
#include<string>
#include<memory>
#include<cassert>
using namespace std;
unique_ptr<string> reverse_string(string const &s);
int main()
{
int count = 0;
string s;
unique_ptr<string> reverse(new string());
unique_ptr<DownwardStack<int>> ptr(new DownwardStack<int>());
cout << "Your string: ";
cin >> s;
reverse = reverse_string(s);
cout << "Your reverse string is: " << *reverse << endl;
if(ptr->IsEmpty())
cout << "ptr is empty" << endl;
else
cout << "ptr is not empty" << endl;
assert(ptr->IsEmpty());
assert(!ptr->IsFull());
ptr->Push(5);
ptr->Push(7);
ptr->Push(10);
ptr->Push(15);
ptr->Push(4);
cout << "Stack size: " << ptr->GetSize() << endl;
cout << "Top element: " << ptr->Peek() << endl;
cout << "Pop one element out." << endl;
ptr->Pop();
cout << "Top element: " << ptr->Peek() << endl;
return 0;
}
unique_ptr<string> reverse_string(string const &s)
{
DownwardStack<char> stack;
cout << s.length() << endl;
// Here it gives me a warning on the for loop
for (int i = 0; i < s.length(); i++)
{
stack.Push(s[i]);
}
unique_ptr<string> result(new string);
// Again it gives me a warning on the for loop
for(int i = 0; i < s.length(); i++)
{
*result += stack.Peek();
stack.Pop();
}
return result;
}
[/code]
This is my header file .h
[code]
#pragma once
#include<cassert>
#include<stack>
#include<string>
// size: number of elements inside the array
const int FIXED_ARRAYED_STACK_CAPACITY = 100;
template<class T>
class DownwardStack
{
public:
DownwardStack();
~DownwardStack();
// 1 step
// O(0)
int GetSize() const {return size;}
bool IsEmpty() const {return (size==0);}
bool IsFull() const {return (size==FIXED_ARRAYED_STACK_CAPACITY);}
T Peek();
void Pop();
void Push(T val);
void Clear();
void DisplayStack();
private:
int size;
T elements[FIXED_ARRAYED_STACK_CAPACITY];
};
// O(1)
template<class T>
DownwardStack<T>::DownwardStack()
{
size = 0;
}
template<class T>
DownwardStack<T>::~DownwardStack()
{
}
// assert = 1 step
// IsEmpty() = 1 step
// total = 2 steps
// f(n) = 2
// O(1)
template<class T>
T DownwardStack<T>::Peek()
{
assert(!IsEmpty());
return elements[FIXED_ARRAYED_STACK_CAPACITY - size];
}
// In order to take something out, it must not be empty
// assert = 1 step
// IsEmpty() = 1 step
// size-- = 1 step
// total = 3 steps
// O(1)
template<class T>
void DownwardStack<T>::Pop()
{
assert(!IsEmpty());
size--;
}
// In order to put in something, the stack must not be full
// assert = 1 step
// IsFull = 1 step
// assignment = 1 step
// size++ = 1 step
// total = 4 steps
// O(1)
template<class T>
void DownwardStack<T>::Push(T val)
{
assert(!IsFull());
elements[FIXED_ARRAYED_STACK_CAPACITY - size - 1] = val;
size++;
}
template<class T>
void DownwardStack<T>::Clear()
{
size = FIXED_ARRAYED_STACK_CAPACITY;
assert(IsEmpty());
}
[/code]

Answer 1

I would implement this as
std::string reverse_string(std::string const & s) {
return {s.rbegin(), s.rend()}; // C++11 or later
return std::string(s.rbegin(), s.rend()); // historical dialects of C++
}
If you really must make life difficult for yourself by using a stack: push each character into it, then pop each out into the new string. By the nature of stacks, you'll pop the characters in the reverse order.
std::string reverse_string(std::string const & s) {
DownwardStack<char> stack;
// write a loop to push each character of "s" onto "stack"
std::string result;
// write a loop to pop each character from "stack" into "result"
return result;
}
If you absolutely have to return a unique pointer, (which you really, really shouldn't), then that becomes
std::unique_ptr<std::string> reverse_string(std::string const & s) {
DownwardStack<char> stack;
// write a loop to push each character of "s" onto "stack"
std::unique_ptr<std::string> result(new std::string);
// write a loop to pop each character from "stack" into "*result"
return result;
}
And do the world a favour: only use new when you actually need it. There's no reason to use unique_ptr either for the stack (make that automatic), or the return value (since std::string is movable).