#include "stack.h"

void stack::ensure_capacity( size_t c ) 
{
   // We keep cap always in powers of two:
   if (c > cap) {
      unsigned int p=1;
      size_t new_cap = 1;   // creating new capacity for new data

      while(1) {            // using while loop to evaluate the smallest p
         new_cap = 1;
         for (size_t i=0; i<p; i++){   
            new_cap = new_cap * 2;
         }
         if (new_cap >= c){
            p--;
            break;
         }
         p++;
      }
      p=p+1;    // incrementing p to satisfy conditions where 2^p >= c
      
      new_cap = 1;
      for (size_t i=0; i<p; i++){   // evaluating 2^p (x is 2^p in this loop)
         new_cap = new_cap * 2;
      } 
      
      std:: string* new_data = new std::string[new_cap];        // creating  new data
      std::copy(data+0, data+sz, new_data);
      delete[] data;  

      cap = new_cap;         // assigning cap,data to new cap, new data
      data = new_data;
   }
}

stack::stack( )
{ 
   cap = 4;
   data = new std::string[cap];
}

stack::stack( const stack& s ): sz(s.sz), cap(s.cap), data(new std::string[s.cap])
{ 
   std::copy(s.data, s.data+sz, data);    // copying information from s to data
}

const stack& stack::operator = ( const stack& s )
{ ensure_capacity(s.sz);
cap = s.cap;      // assigning cap to s.cap
delete[] data;     
data = new std::string [cap];    // allocating new memory for data
std::copy(s.data, s.data+sz, data);          // copying information from s to data
return *this;
}

stack::~stack( )
{ 
   delete[] data;
}

void stack::push( const std::string& val )
{ 
   ensure_capacity(sz);
   data[sz] = val;
   sz++;
}

void stack::pop( )
{     if (sz==0){
         throw std:: runtime_error("Error, stack is empty");
   } 
   sz--;
}

void stack::clear( )
{ sz = 0;
}

void stack::reset( size_t s )
{ sz=s;
}

const std::string& stack::peek( ) const
{
   if (sz != 0){
      return data[sz-1];
   } else {
      throw std:: runtime_error("Error, stack is empty");
   }
}

size_t stack::size( ) const
{ return sz;
}

bool stack::empty( ) const
{ if(sz == 0){
   return true;
} else {
   return false;
}
}

stack::stack( std::initializer_list< std::string > values )
{ 
   ensure_capacity(values.size()+sz);
   std::copy(values.begin(), values.end(), data);
   sz = values.size();
}

void stack::push( std::initializer_list< std::string > values )
{ 
   ensure_capacity(values.size()+sz);
   std::copy(values.begin(), values.end(), data + sz);
   sz = sz + values.size();
}

void stack::print( std::ostream& out ) const 
{
   for (size_t i=0; i < sz; i++){
      out << data[i] << "\n";
      if(i > 0){
         out << ",";
      }
   }
}

C++ Online Compiler

Write, Run & Share C++ code online using OneCompiler's C++ online compiler for free. It's one of the robust, feature-rich online compilers for C++ language, running on the latest version 17. Getting started with the OneCompiler's C++ compiler is simple and pretty fast. The editor shows sample boilerplate code when you choose language as C++ and start coding!

Read inputs from stdin

OneCompiler's C++ online compiler supports stdin and users can give inputs to programs using the STDIN textbox under the I/O tab. Following is a sample program which takes name as input and print your name with hello.

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

int main() 
{
    string name;
    cout << "Enter name:";
    getline (cin, name);
    cout << "Hello " << name;
    return 0;
}

About C++

C++ is a widely used middle-level programming language.

  • Supports different platforms like Windows, various Linux flavours, MacOS etc
  • C++ supports OOPS concepts like Inheritance, Polymorphism, Encapsulation and Abstraction.
  • Case-sensitive
  • C++ is a compiler based language
  • C++ supports structured programming language
  • C++ provides alot of inbuilt functions and also supports dynamic memory allocation.
  • Like C, C++ also allows you to play with memory using Pointers.

Syntax help

Loops

1. If-Else:

When ever you want to perform a set of operations based on a condition If-Else is used.

if(conditional-expression) {
   //code
}
else {
   //code
}

You can also use if-else for nested Ifs and If-Else-If ladder when multiple conditions are to be performed on a single variable.

2. Switch:

Switch is an alternative to If-Else-If ladder.

switch(conditional-expression){    
case value1:    
 // code    
 break;  // optional  
case value2:    
 // code    
 break;  // optional  
......    
    
default:     
 code to be executed when all the above cases are not matched;    
}

3. For:

For loop is used to iterate a set of statements based on a condition.

for(Initialization; Condition; Increment/decrement){  
  //code  
}

4. While:

While is also used to iterate a set of statements based on a condition. Usually while is preferred when number of iterations are not known in advance.

while (condition) {  
// code 
}

5. Do-While:

Do-while is also used to iterate a set of statements based on a condition. It is mostly used when you need to execute the statements atleast once.

do {  
 // code 
} while (condition);

Functions

Function is a sub-routine which contains set of statements. Usually functions are written when multiple calls are required to same set of statements which increases re-usuability and modularity. Function gets run only when it is called.

How to declare a Function:

return_type function_name(parameters);

How to call a Function:

function_name (parameters)

How to define a Function:

return_type function_name(parameters) {  
 // code
}