Putting things together

Putting things together

Requirements:
Linux Distribution
g++
any text editor

My Setup:
Debian 10
g++ version 6.3.0
pluma

I wasnt 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];

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

  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 [c/f] 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{

  protected:
    double m_degrees;

  public:
    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(){}

    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 {

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

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

};

class Fahrenheit : public Temperature {

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

  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){
    printUsage();
    return -1;
  }

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

}

void printUsage(){
  std::cout <<"Usage: temp [c/f] value" << std::endl;
}

 

Leave a Reply

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out /  Change )

Google photo

You are commenting using your Google account. Log Out /  Change )

Twitter picture

You are commenting using your Twitter account. Log Out /  Change )

Facebook photo

You are commenting using your Facebook account. Log Out /  Change )

Connecting to %s