# 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 &lt;iostream&gt;
#include &lt;string&gt;

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 &lt;&lt; toCelsius(degree) &lt;&lt; std::endl;
else if(isCelsius(convert))
std::cout &lt;&lt; toFahrenheit(degree) &lt;&lt; std::endl;
else
printUsage();

return 0;
}

const double temp(const char * var){
std::string::size_type sst;
return std::stod(var,&amp;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 &lt;&lt;"Usage: temp  value" &lt;&lt; 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 &lt;iostream&gt;
#include &lt;string&gt;

class Temperature{

protected:
double m_degrees;

public:
Temperature(double degrees): m_degrees(degrees){}
Temperature(const Temperature &amp; copy): m_degrees(copy.m_degrees) {}
Temperature(Temperature &amp;&amp; move) : m_degrees(std::move(move.m_degrees)){}
~Temperature(){}

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

Temperature &amp; operator=(Temperature &amp;&amp; move){
this-&gt;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 &lt; 3 || argc &gt; 3){
printUsage();
return -1;
}

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

}

void printUsage(){
std::cout &lt;&lt;"Usage: temp  value" &lt;&lt; std::endl;
}
```