Putting things together


  • Linux Distribution
  • g++
  • any text editor

My Setup:

  • Debian 10
  • g++ version 6.3.0
  • pluma

I wasn’t sure of what exactly to go over next, so this tutorial will be a brief
tutorial of my thought process to create something. In my C tutorials, we
created a temperature converter between Fahrenheit and Celsius . Today we will
be recreating it in multiple ways. We will go over an object-oriented approach,
and a functional approach, the procedural approach is the one we had already
created. So lets begin!

Ok so for our first example will be the functional example. First I would like
to say i am not extremely confident in functional programming, I am more use to
procedural, however what I know about functional programming is that it doesnt
like to change states, or contain mutable data. So I started off by defining a
couple things. These include getting the temp and storing it in a constant,
defining what when to determine if the temperature we are converting is in
Fahrenheit or Celsius. If the second argument to the program is a ‘c’ , we know
it is a Fahrenheit temperature needing to be converted into a Celsius
temperature. If the second argument is a ‘f’, then we know it is a Celsius
temperature needing to be converted into a Fahrenheit temperature. Next i define
the conversion in 2 functions, toFahrenheit(const double) and toCelsius(const
double). Last I just added a printUsage function like my C Program’s, except
I used std::cout rather then printf.

#include <iostream>
#include <string>

const double temp(const char * var);
const bool isFahrenheit(const char arg);
const bool isCelsius(const char arg);
const double toFahrenheit(const double c);
const double toCelsius(const double f);
void printUsage();

int main(int argc, char * argv[]){

  const double degree = temp(argv[2]);
  const char convert = argv[1][0];

    std::cout << toCelsius(degree) << std::endl;
  else if(isCelsius(convert))
    std::cout << toFahrenheit(degree) << std::endl;

  return 0;

const double temp(const char * var){
    std::string::size_type sst;
  return std::stod(var,&sst);

const bool isFahrenheit(const char arg){
  return arg == 'c';

const bool isCelsius(const char arg){
  return arg == 'f';

const double toFahrenheit(const double c){
  return (c * 1.8f) + 32;
const double toCelsius(const double f){
  return (f - 32) * 5/9 ;

void printUsage(){
  std::cout << "Usage: temp  value" << std::endl;

Ok so now that we have our functional example, lets go over an object-oriented
approach. In my head, I will consider temperature as a base class and the type
of temperature as a derived class. Within Temperature i defined a toFahrenheit
and a toCelsius virtual function, and then extended the functions once i got to
the derived classes. I make use of the string header file for the std::stod
function, which takes in a string and outputs the double value of the string.
I also create a temporary string in order to hold it, since the argument comes
in form of a char array. Lets look at it:

#include <iostream>
#include <string>

class Temperature{

    double m_degrees;

    Temperature(double degrees): m_degrees(degrees){}
    Temperature(const Temperature & copy): m_degrees(copy.m_degrees) {}
    Temperature(Temperature && move) : m_degrees(std::move(move.m_degrees)){}

    Temperature & operator=(const Temperature & copy){
      this->m_degrees = copy.m_degrees;
      return *this;

    Temperature & operator=(Temperature && move){
      this->m_degrees = std::move(move.m_degrees);
      return *this;

//Marking these as virtual
  virtual double toCelsius() = 0;
  virtual double toFahrenheit() = 0;


class Celsius : public Temperature {

  Celsius(double degrees):Temperature(degrees){}

  double toCelsius(){ return m_degrees;}
  double toFahrenheit(){
    return ( 1.8f * m_degrees) + 32.0 ;


class Fahrenheit : public Temperature {

  Fahrenheit(double degrees):Temperature(degrees){}

  double toCelsius(){
    return ( m_degrees - 32.0 ) *  (5.0 / 9.0);
  double toFahrenheit(){ return m_degrees;}

void printUsage();

int main(int argc, char * argv[]){

  Temperature * temp;
  std::string::size_type sz;
  if(argc < 3 || argc > 3){
    return -1;

    case 'c':
    temp = new Fahrenheit(std::stod(std::string(argv[2]),&sz));
    std::cout << temp->toCelsius() << std::endl;
    case 'f':
    temp = new Celsius(std::stod(std::string(argv[2]),&sz));
    std::cout << temp->toFahrenheit() << std::endl;
    std::cout << "Error, incorrect syntax" << std::endl;
    return -2;
    delete temp;
    return 0;


void printUsage(){
  std::cout << "Usage: temp  value" << std::endl;

Leave a Reply