larry and jen do roman numerals in c++

Larry and Jen do Roman Numerals

in C++

by Jon Jagger and Olve Maudal

http://www.slideshare.net/olvemaudal/deep-c

Larry and Jen first appeared in the popular Deep C (and C++) presentation





Jen, will you help me do some C++ practice?

Jen, will you help me do some C++ practice?

Sure Larry.

Given a positive integer number (eg 42) determineits Roman numeral representation as a String (eg "XLII").The Roman 'letters' are:

1 -> "I" | 10 -> "X" | 100 -> "C" | 1000 -> "M"2 -> "II" | 20 -> "XX" | 200 -> "CC" | 2000 -> "MM"3 -> "III" | 30 -> "XXX" | 300 -> "CCC" | 3000 -> "MMM"4 -> "IV" | 40 -> "XL" | 400 -> "CD" | 4000 -> "MMMM"5 -> "V" | 50 -> "L" | 500 -> "D"6 -> "VI" | 60 -> "LX" | 600 -> "DC" 7 -> "VII" | 70 -> "LXX" | 700 -> "DCC" 8 -> "VIII" | 80 -> "LXXX" | 800 -> "DCCC" 9 -> "IX" | 90 -> "XC" | 900 -> "CM"

You cannot write numerals like IM for 999.Wikipedia states "Modern Roman numerals are written byexpressing each digit separately starting with theleftmost digit and skipping any digit with a value of zero."

Examples:o) 1990 -> "MCMXC" (1000 -> "M" + 900 -> "CM" + 90 -> "XC")o) 2008 -> "MMVIII" (2000 -> "MM" + 8 -> "VIII")o) 99 -> "XCIX" ( 90 -> "XC" + 9 -> "IX")o) 47 -> "XLVII" ( 40 -> "XL" + 7 -> "VII")

How about the roman numerals kata?

Given a positive integer number (eg 42) determineits Roman numeral representation as a String (eg "XLII").The Roman 'letters' are:

1 -> "I" | 10 -> "X" | 100 -> "C" | 1000 -> "M"2 -> "II" | 20 -> "XX" | 200 -> "CC" | 2000 -> "MM"3 -> "III" | 30 -> "XXX" | 300 -> "CCC" | 3000 -> "MMM"4 -> "IV" | 40 -> "XL" | 400 -> "CD" | 4000 -> "MMMM"5 -> "V" | 50 -> "L" | 500 -> "D"6 -> "VI" | 60 -> "LX" | 600 -> "DC" 7 -> "VII" | 70 -> "LXX" | 700 -> "DCC" 8 -> "VIII" | 80 -> "LXXX" | 800 -> "DCCC" 9 -> "IX" | 90 -> "XC" | 900 -> "CM"

You cannot write numerals like IM for 999.Wikipedia states "Modern Roman numerals are written byexpressing each digit separately starting with theleftmost digit and skipping any digit with a value of zero."

Examples:o) 1990 -> "MCMXC" (1000 -> "M" + 900 -> "CM" + 90 -> "XC")o) 2008 -> "MMVIII" (2000 -> "MM" + 8 -> "VIII")o) 99 -> "XCIX" ( 90 -> "XC" + 9 -> "IX")o) 47 -> "XLVII" ( 40 -> "XL" + 7 -> "VII")

How about the roman numerals kata?

ok

#include "to_roman.hpp"#include <cassert>#include <iostream>

int main(){ std::cout << "All tests passed" << std::endl;}

to_roman.tests.cppI'll start with a test.1 should be I.



to_roman.tests.cppI'll start with a test.1 should be I.#include "to_roman.hpp"

#include <cassert>#include <iostream>




to_roman.tests.cppI'll start with a test.1 should be I.#include "to_roman.hpp"



static void test_1_is_I(){ assert(to_roman(1) == "I");}

Here's my header file, to_roman.hpp

#ifndef TO_ROMAN_INCLUDED#define TO_ROMAN_INCLUDED

#include <string>

std::string to_roman(int number);

#endif



#include <string>


#endif


Here's my source file, to_roman.cpp


#include <string>


#endif



#include "to_roman.hpp"

std::string to_roman(int number){ return "";}


#include <string>


#endif


ok




How are you building and running?


With this.


$ cc *.cpp && ./a.out

With this.



With this.

Try it.



With this.

Try it.

$ cc *.cpp && ./a.outAll tests passed



With this.

Try it.


Eh? That's not right. It should have failed!



With this.

Try it.


Eh? That's not right. It should have failed!

Let's see the tests again.




Hmmmm.

Of course. We're not calling the test! #include "to_roman.hpp"




Hmmmm.





Hmmmm.

That's easy to fix.





Hmmmm.

That's easy to fix.



int main(){

std::cout << "All tests passed" << std::endl;}





Hmmmm.

That's easy to fix.



int main(){


test_1_is_I();





Hmmmm.


That's easy to fix.



int main(){


test_1_is_I();





Hmmmm.

$ cc *.cpp && ./a.out$ cc *.cpp && ./a.outAssertion failed: (to_roman(1) == "I")

That's easy to fix.



int main(){


test_1_is_I();





Hmmmm.

$ cc *.cpp && ./a.out$ cc *.cpp && ./a.outAssertion failed: (to_roman(1) == "I")

That's easy to fix.



int main(){


test_1_is_I();

Now it fails.

I can simply change the the return value to

make it pass.




make it pass.


std::string to_roman(int number){ return "I";}


make it pass.





make it pass.

$ cc *.cpp && ./a.out$ cc *.cpp && ./a.out All tests passed




make it pass.

$ cc *.cpp && ./a.out$ cc *.cpp && ./a.out All tests passed

ok



Let's write another test. 2 should be II

I think there is a problem we should fix first.




What problem?



What problem?

We've fixed the immediate issue by calling the function. But what happens the next

time we forget?



What problem?

We've fixed the immediate issue by calling the function. But what happens the next

time we forget?

What do you suggest?

Could the compiler detect when we have a function that is defined

but not used?


but not used?

A command line option?

Yes. It's one of the smells the compiler can detect with the

-Wall flag.


but not used?


Yes. It's one of the smells the compiler can detect with the

-Wall flag.

ok. Let me try that.


but not used?




int main(){ test_1_is_I(); std::cout << "All tests passed" << std::endl;}

I'll comment out the call




I'll comment out the call #include "to_roman.hpp"#include <cassert>#include <iostream>


int main(){ /test_1_is_I(); std::cout << "All tests passed" << std::endl;}




I'll comment out the call #include "to_roman.hpp"#include <cassert>#include <iostream>





int main(){ //test_1_is_I(); std::cout << "All tests passed" << std::endl;}





and add the -Wall flag




















-Wall














-Wall$ cc -Wall *.cpp && ./a.outwarning: 'void test_1_is_I()' is defined but not usedAll tests passed








now I get the warning







-Wall$ cc -Wall *.cpp && ./a.outwarning: 'void test_1_is_I()' is defined but not usedAll tests passed




Turning the warning into an error would be even better.

We can do that with the -Werror flag






Agreed.




$ cc -Wall *.cpp && ./a.out



Agreed.








Agreed.







$ cc -Wall *.cpp && ./a.out-Werror

Agreed.







$ cc -Wall *.cpp && ./a.out-Werror$ cc -Wall -Werror *.cpp && ./a.outerror: 'void test_1_is_I()' is defined but not used

Agreed.




I'll uncomment the comment so the test passes again.





$ cc -Wall -Werror *.cpp && ./a.out


















$ cc -Wall -Werror *.cpp && ./a.outAll tests passed





Now we can write the next test.









...static void test_1_is_I(){ assert(to_roman(1) == "I");}


2 should be II



2 should be II


int main(){ test_1_is_I();




2 should be II




test_2_is_II();



2 should be II




test_2_is_II();


int main(){ test_1_is_I(); test_2_is_II(); std::cout << "All tests passed" << std::endl;}



2 should be II




test_2_is_II();



static void test_2_is_II(){ assert(to_roman(2) == "II");}



2 should be II

It should fail because to_roman still always

returns "I"




test_2_is_II();






2 should be II



returns "I"




test_2_is_II();






2 should be II

$ cc -Wall -Werror *.cpp && ./a.out$ cc -Wall -Werror *.cpp && ./a.outvoid test_2_is_II(): Assertion `to_roman(2) == "II"' failed.


returns "I"




test_2_is_II();






2 should be II

$ cc -Wall -Werror *.cpp && ./a.out$ cc -Wall -Werror *.cpp && ./a.outvoid test_2_is_II(): Assertion `to_roman(2) == "II"' failed.

Let's make it pass.


returns "I"




test_2_is_II();






How about this?



How about this?#include "to_roman.hpp"

std::string to_roman(int number){

return "I";}





return "I";}

if (number == 1)





return "I";}

if (number == 1)


std::string to_roman(int number){ if (number == 1) return "I";}





return "I";}

if (number == 1)




std::string to_roman(int number){ if (number == 1) return "I";

}





return "I";}

if (number == 1)





} if (number == 2)





return "I";}

if (number == 1)





} if (number == 2)


std::string to_roman(int number){ if (number == 1) return "I"; if (number == 2)

}





return "I";}

if (number == 1)





} if (number == 2)



} return "II";



How about this?

Try it!



return "I";}

if (number == 1)





} if (number == 2)



} return "II";



How about this?

Try it!




return "I";}

if (number == 1)





} if (number == 2)



} return "II";



How about this?

Try it!

$ cc -Wall -Werror *.cpp && ./a.out$ cc -Wall -Werror *.cpp && ./a.outerror: control reaches end of non-void function



return "I";}

if (number == 1)





} if (number == 2)



} return "II";



How about this?

Try it!


Eh?



return "I";}

if (number == 1)





} if (number == 2)



} return "II";



How about this?

Try it!


Eh?

Ah! It's saying that if number doesn't equal one or two then there is no

return statement.



return "I";}

if (number == 1)





} if (number == 2)



} return "II";



How about this?

Try it!


Eh?

Exactly.


return statement.



return "I";}

if (number == 1)





} if (number == 2)



} return "II";



How about this?

Try it!


Eh?

Exactly.

That's easy to fix.


return statement.



return "I";}

if (number == 1)





} if (number == 2)



} return "II";


std::string to_roman(int number){ if (number == 1) return "I"; if (number == 2) return "II";}





if (number == 1) return "I"; if (number == 2) return "II";}






std::string roman = "";








std::string to_roman(int number){ std::string roman = ""; if (number == 1) if (number == 2) return "II";}









roman = "I";









roman = "I";


std::string to_roman(int number){ std::string roman = ""; if (number == 1) roman = "I"; if (number == 2)

}









roman = "I";



} roman = "II";









roman = "I";



} roman = "II";


std::string to_roman(int number){ std::string roman = ""; if (number == 1) roman = "I"; if (number == 2) roman = "II";

}









roman = "I";



} roman = "II";



} return roman;

How about this?

Looks good.









roman = "I";



} roman = "II";



} return roman;

How about this?

Looks good.










roman = "I";



} roman = "II";



} return roman;

How about this?

Looks good.

$ cc -Wall -Werror *.cpp && ./a.out$ cc -Wall -Werror *.cpp && ./a.outAll tests passed









roman = "I";



} roman = "II";



} return roman;

How about this?

Looks good.


Yessss.









roman = "I";



} roman = "II";



} return roman;

How about this?

Looks good.


Yessss.

Now another test.









roman = "I";



} roman = "II";



} return roman;

How about this?

Looks good.


Yessss.

Now another test.

ok









roman = "I";



} roman = "II";



} return roman;




I'll add a test for 3 being III. That should fail.







int main(){ test_1_is_I(); test_2_is_II();










test_3_is_III();









test_3_is_III();



int main(){ test_1_is_I(); test_2_is_II(); test_3_is_III(); std::cout << "All tests passed" << std::endl;}









test_3_is_III();




static void test_3_is_III(){ assert(to_roman(3) == "III");}










test_3_is_III();









$ cc -Wall -Werror *.cpp && ./a.out$ cc -Wall -Werror *.cpp && ./a.outvoid test_3_is_III(): Assertion `to_roman(3) == "III"' failed...Aborted





test_3_is_III();










Now I'll make it pass.





test_3_is_III();










Now I'll make it pass.

ok





test_3_is_III();






std::string to_roman(int number){ std::string roman = ""; if (number == 1) roman = "I"; if (number == 2) roman = "II"; return roman;}

How about this?




How about this?




return roman;}



How about this?




return roman;}

if (number == 3) roman = "III";



How about this?

Aha...




return roman;}




How about this?

Aha...


Yessss.



return roman;}




How about this?

Aha...


Yessss.

Now another test.



return roman;}




How about this?

Aha...


Yessss.

Now another test.

Hmmmm.....



return roman;}






Are you thinking we should refactor first?






Yes.






Yes.

I'd start with the tests.





What about the tests?






The name of each test repeats its body. In this case the test name adds

nothing. How about collapsing them all into a

single test.






The name of each test repeats its body. In this case the test name adds

nothing. How about collapsing them all into a

single test.

Can you show me?

How about this.





How about this.

...static void test_to_roman(){ assert(to_roman(1) == "I"); assert(to_roman(2) == "II"); assert(to_roman(3) == "III");}

int main(){ test_to_roman(); std::cout << "All tests passed" << std::endl;}

How about this.




How about this.

Everything still passes.




Next I'd refactor the code.


std::string to_roman(int number){ std::string roman = ""; if (number == 1) roman = "I"; if (number == 2) roman = "II"; if (number == 3) roman = "III"; return roman;}




Yeah. An endless sequence of if statements isn't going to

be much of a solution.






Can I show you something neat?






Can I show you something neat?

Sure

First I'll refactor the code so that each if statement concatenates a single I.




std::string to_roman(int number){ std::string roman = ""; if (number >= 1) roman = "I"; if (number == 2) roman = "II"; if (number == 3) roman = "III"; return roman;}


std::string to_roman(int number){ std::string roman = ""; if (number >= 1) roman += "I"; if (number == 2) roman = "II"; if (number == 3) roman = "III"; return roman;}


std::string to_roman(int number){ std::string roman = ""; if (number >= 1) roman += "I"; if (number >= 2) roman = "II"; if (number == 3) roman = "III"; return roman;}


std::string to_roman(int number){ std::string roman = ""; if (number >= 1) roman += "I"; if (number >= 2) roman = "I"; if (number == 3) roman = "III"; return roman;}


std::string to_roman(int number){ std::string roman = ""; if (number >= 1) roman += "I"; if (number >= 2) roman += "I"; if (number == 3) roman = "III"; return roman;}


std::string to_roman(int number){ std::string roman = ""; if (number >= 1) roman += "I"; if (number >= 2) roman += "I"; if (number >= 3) roman = "III"; return roman;}


std::string to_roman(int number){ std::string roman = ""; if (number >= 1) roman += "I"; if (number >= 2) roman += "I"; if (number >= 3) roman = "II"; return roman;}


std::string to_roman(int number){ std::string roman = ""; if (number >= 1) roman += "I"; if (number >= 2) roman += "I"; if (number >= 3) roman = "I"; return roman;}























std::string to_roman(int number){ std::string roman = ""; if (number >= 1) roman += "I"; if (number >= 2) roman += "I"; if (number >= 3) roman += "I"; return roman;}

I add braces to the if statements.







std::string to_roman(int number){ std::string roman = ""; if (number >= 1) { roman += "I"; } if (number >= 2) roman += "I"; if (number >= 3) roman += "I"; return roman;}







std::string to_roman(int number){ std::string roman = ""; if (number >= 1) { roman += "I"; } if (number >= 2) { roman += "I"; } if (number >= 3) roman += "I"; return roman;}









std::string to_roman(int number){ std::string roman = ""; if (number >= 1) { roman += "I"; } if (number >= 2) { roman += "I"; } if (number >= 3) { roman += "I"; } return roman;}

Now I make the three ifs exactly the same.







std::string to_roman(int number){ std::string roman = ""; if (number >= 1) { roman += "I"; number--; } if (number >= 2) { roman += "I"; } if (number >= 3) { roman += "I"; } return roman;}









std::string to_roman(int number){ std::string roman = ""; if (number >= 1) { roman += "I"; number--; } if (number >= 1) { roman += "I"; number--; } if (number >= 3) { roman += "I"; } return roman;}













std::string to_roman(int number){ std::string roman = ""; if (number >= 1) { roman += "I"; number--; } if (number >= 1) { roman += "I"; number--; } if (number >= 1) { roman += "I"; number--; } return roman;}

Finally I can collapse the three identical if statements into a single while statement.





std::string to_roman(int number){ std::string roman = ""; if (number >= 1) { roman += "I"; number--; } return roman;}



std::string to_roman(int number){ std::string roman = ""; (number >= 1) { roman += "I"; number--; } return roman;}



std::string to_roman(int number){ std::string roman = ""; while (number >= 1) { roman += "I"; number--; } return roman;}



Cool. The repeated if statements are just like an unrolled while statement.



Cool. The repeated if statements are just like an unrolled while statement.

Exactly.

Any more refactoring?

What do you think?


What do you think?


I can't see anything.

What do you think?



ok. Let's move on.

What do you think?



ok. Let's move on.

Let's add a test for 4 being IV

What do you think?



ok. Let's move on.


I'd do 10 being X next.

What do you think?



ok. Let's move on.


I'd do 10 being X next.

ok

I'll add the test for 10 being X



...static void test_to_roman(){ assert(to_roman(1) == "I"); assert(to_roman(2) == "II"); assert(to_roman(3) == "III");

}



} assert(to_roman(10) == "X");


$ cc -Wall -Werror *.cpp && ./a.out$ cc -Wall -Werror *.cpp && ./a.outAssertion `to_roman(10) == "X"' failed.Aborted




It fails as expected.




I can make it pass by repeating the same while statement but using 10 and X instead

of 1 and I.




of 1 and I.


std::string to_roman(int number){ std::string roman = ""; while (number >= 1) { roman += "I"; number--; }

return roman;}


of 1 and I.



return roman;}

while (number >= 10) { roman += "X"; number -= 10; }


of 1 and I.




return roman;}



of 1 and I.

Eh? It still fails.




return roman;}


It would really help if the console output told us what to_roman is actually returning.

...static void test_to_roman(){ assert(to_roman(1) == "I"); assert(to_roman(2) == "II"); assert(to_roman(3) == "III"); assert(to_roman(10) == "X");}

$ cc -Wall -Werror *.cpp && ./a.outAssertion `to_roman(10) == "X"' failed.Aborted


Yes it would.




Yes it would.


Let's rework the test to do that.



Yes it would.


Let's rework the test to do that.

ok


Let's make a function called assert_to_roman.



ok



ok

...static void test_to_roman(){ assert_to_roman(1,"I"); assert(to_roman(2) == "II"); assert(to_roman(3) == "III"); assert(to_roman(10) == "X");}


ok

...static void test_to_roman(){ assert_to_roman(1,"I"); assert_to_roman(2,"II"); assert(to_roman(3) == "III"); assert(to_roman(10) == "X");}


ok

...static void test_to_roman(){ assert_to_roman(1,"I"); assert_to_roman(2,"II"); assert_to_roman(3,"III"); assert(to_roman(10) == "X");}


ok

...static void test_to_roman(){ assert_to_roman(1,"I"); assert_to_roman(2,"II"); assert_to_roman(3,"III"); assert_to_roman(10,"X");}

Now we write assert_to_roman

static void assert_to_roman(int arabic, const std::string & expected){ const std::string actual = to_roman(arabic); if (expected != actual) { std::cerr << "expected: to_roman" << '(' << arabic << ") == " << '"' << expected << '"' << std::endl; std::cerr << " actual: to_roman" << '(' << arabic << ") == " << '"' << actual << '"' << std::endl; assert(false); }}...




$ cc -Wall -Werror *.cpp && ./a.out$ cc -Wall -Werror *.cpp && ./a.outexpected: to_roman(10) == "X" actual: to_roman(10) == "IIIIIIIIII"Assertion `false' failed.Aborted




That's a much more helpful message.

$ cc -Wall -Werror *.cpp && ./a.outexpected: to_roman(10) == "X" actual: to_roman(10) == "IIIIIIIIII"Assertion `false' failed.Aborted


std::string to_roman(int number){ std::string roman = ""; while (number >= 1) { roman += "I"; number--; } while (number >= 10) { roman += "X"; number -= 10; } return roman;}


So why isn't to_roman working for X?

Ah of course. The while statements are the wrong way round.


std::string to_roman(int number){ std::string roman = ""; while (number >= 1) { roman += "I"; number--; } while (number >= 10) { roman += "X"; number -= 10; } return roman;}


So why isn't to_roman working for X?

That's easy to fix.


std::string to_roman(int number){ std::string roman = "";

return roman;}

while (number >= 1) { roman += "I"; number--; } while (number >= 10) { roman += "X"; number -= 10; }

That's easy to fix.



return roman;}

while (number >= 1) { roman += "I"; number--; }


That's easy to fix.



return roman;}




That's easy to fix.



return roman;}


Yes. We're green again.



#include "to_roman.hpp"#include <cassert>#include <iostream>...static void test_to_roman(){ assert_to_roman(1,"I"); assert_to_roman(2,"II"); assert_to_roman(3,"III"); assert_to_roman(10,"X");}

I think tests for 20 and 30 should pass straight away.

#include "to_roman.hpp"#include <cassert>#include <iostream>...static void test_to_roman(){ assert_to_roman(1,"I"); assert_to_roman(2,"II"); assert_to_roman(3,"III"); assert_to_roman(10,"X");}

I agree.


#include "to_roman.hpp"#include <cassert>#include <iostream>...static void test_to_roman(){ assert_to_roman(1,"I"); assert_to_roman(2,"II"); assert_to_roman(3,"III"); assert_to_roman(10,"X");

}

I agree.



}

assert_to_roman(20,"XX"); assert_to_roman(30,"XXX");

I agree.




}


I agree.


I think 33 should pass already.

#include "to_roman.hpp"#include <cassert>#include <iostream>...static void test_to_roman(){ assert_to_roman( 1,"I"); assert_to_roman( 2,"II"); assert_to_roman( 3,"III"); assert_to_roman(10,"X"); assert_to_roman(20,"XX"); assert_to_roman(30,"XXX");}


I do too.

#include "to_roman.hpp"#include <cassert>#include <iostream>...static void test_to_roman(){ assert_to_roman( 1,"I"); assert_to_roman( 2,"II"); assert_to_roman( 3,"III"); assert_to_roman(10,"X"); assert_to_roman(20,"XX"); assert_to_roman(30,"XXX");}


I do too.

#include "to_roman.hpp"#include <cassert>#include <iostream>...static void test_to_roman(){ assert_to_roman( 1,"I"); assert_to_roman( 2,"II"); assert_to_roman( 3,"III"); assert_to_roman(10,"X"); assert_to_roman(20,"XX"); assert_to_roman(30,"XXX");

}


I do too.


} assert_to_roman(33,"XXXIII");



I do too.



What next?

What next?

How about 100 ?

What next?

How about 100 ?

That should be C

#include "to_roman.hpp"#include <cassert>#include <iostream>...static void test_to_roman(){ assert_to_roman( 1,"I"); assert_to_roman( 2,"II"); assert_to_roman( 3,"III"); assert_to_roman(10,"X"); assert_to_roman(20,"XX"); assert_to_roman(30,"XXX"); assert_to_roman(33,"XXXIII");}

#include "to_roman.hpp"#include <cassert>#include <iostream>...static void test_to_roman(){ assert_to_roman( 1,"I"); assert_to_roman( 2,"II"); assert_to_roman( 3,"III"); assert_to_roman(10,"X"); assert_to_roman(20,"XX"); assert_to_roman(30,"XXX"); assert_to_roman(33,"XXXIII");

}


} assert_to_roman(100,"C");

This will fail with 10 X's




$ cc -Wall -Werror *.cpp && ./a.out$ cc -Wall -Werror *.cpp && ./a.outexpected: to_roman(100) == "C" actual: to_roman(100) == "XXXXXXXXXX"....int main(): Assertion `false' failed.Aborted




$ cc -Wall -Werror *.cpp && ./a.out$ cc -Wall -Werror *.cpp && ./a.outexpected: to_roman(100) == "C" actual: to_roman(100) == "XXXXXXXXXX"....int main(): Assertion `false' failed.Aborted

Excellent!




std::string to_roman(int number){ std::string roman = ""; while (number >= 10) { roman += "X"; number -= 10; } while (number >= 1) { roman += "I"; number--; } return roman;}

To make it pass I just need to add another while statement.






while (number >= 10) { roman += "X"; number -= 10; } while (number >= 1) { roman += "I"; number--; } return roman;}







while (number >= 100) { roman += "C"; number -= 100; }



std::string to_roman(int number){ std::string roman = ""; while (number >= 100) { roman += "C"; number -= 100; } while (number >= 10) { roman += "X"; number -= 10; } while (number >= 1) { roman += "I"; number--; } return roman;}

And now?


The three while statements are duplicating each other. So let's

refactor those.



And now?

First I'll introduce a simple struct to

represent a roman digit.











struct digit{ int arabic; std::string roman;};

Now I introduce 100 and "C" as a digit.








const digit digits[] = { { 100, "C" },};

Now I use the first digit instead of 100

and "C".






and "C".




std::string to_roman(int number){ std::string roman = ""; while (number >= { roman += number -= } while (number >= 10) { roman += "X"; number -= 10; } while (number >= 1) { roman += "I"; number--; } return roman;}


and "C".





digits[0].arabic)

digits[0].roman; digits[0].arabic;



and "C".





digits[0].arabic)




and "C".





digits[0].arabic)


Nice.

Now I repeat for the next digit, 10

and "X".

#include "to_roman.hpp"...const digit digits[] = { { 100, "C" },};

std::string to_roman(int number){ std::string roman = ""; while (number >= digits[0].arabic) { roman += digits[0].roman; number -= digits[0].arabic; } while (number >= 10) { roman += "X"; number -= 10; } while (number >= 1) { roman += "I"; number--; } return roman;}


and "X".

#include "to_roman.hpp"...const digit digits[] = { { 100, "C" }, };



and "X".



{ 10, "X" },


and "X".



{ 10, "X" },

#include "to_roman.hpp"...const digit digits[] = { { 100, "C" }, { 10, "X" },};

std::string to_roman(int number){ std::string roman = ""; while (number >= digits[0].arabic) { roman += digits[0].roman; number -= digits[0].arabic; } while (number >= { roman += number -= } while (number >= 1) { roman += "I"; number--; } return roman;}


and "X".



{ 10, "X" },



digits[1].arabic)

digits[1].roman;digits[1].arabic;



and "X".



{ 10, "X" },



digits[1].arabic)


I repeat again for the next

digit, 1 and "I".

#include "to_roman.hpp"...const digit digits[] = { { 100, "C" }, { 10, "X" }, };

std::string to_roman(int number){ std::string roman = ""; while (number >= digits[0].arabic) { roman += digits[0].roman; number -= digits[0].arabic; } while (number >= digits[1].arabic) { roman += digits[1].roman; number -= digits[1].arabic; } while (number >= 1) { roman += "I"; number--; } return roman;}


digit, 1 and "I".

#include "to_roman.hpp"...const digit digits[] = { { 100, "C" }, { 10, "X" },

};



digit, 1 and "I".


};


{ 1, "I" },


digit, 1 and "I".


};


{ 1, "I" },

#include "to_roman.hpp"...const digit digits[] = { { 100, "C" }, { 10, "X" }, { 1, "I" },};

std::string to_roman(int number){ std::string roman = ""; while (number >= digits[0].arabic) { roman += digits[0].roman; number -= digits[0].arabic; } while (number >= digits[1].arabic) { roman += digits[1].roman; number -= digits[1].arabic; } while (number >= { roman += number } return roman;}


digit, 1 and "I".


};


{ 1, "I" },



digits[2].arabic)

-= digits[2].arabic;digits[2].roman;



digit, 1 and "I".


};


{ 1, "I" },



digits[2].arabic)


Now I can replace each use of 0 with

an introduced variable.

...std::string to_roman(int number){ std::string roman = ""; while (number >= digits[0].arabic) { roman += digits[0].roman; number -= digits[0].arabic; } while (number >= digits[1].arabic) { roman += digits[1].roman; number -= digits[1].arabic; } while (number >= digits[2].arabic) { roman += digits[2].roman; number -= digits[2].arabic; } return roman;}



...std::string to_roman(int number){ std::string roman = "";

while (number >= digits[ ].arabic) { roman += digits[ ].roman; number -= digits[ ].arabic; } while (number >= digits[1].arabic) { roman += digits[1].roman; number -= digits[1].arabic; } while (number >= digits[2].arabic) { roman += digits[2].roman; number -= digits[2].arabic; } return roman;}





std::size_t i = 0;i

ii

And replace 1 with the introduced

variable....std::string to_roman(int number){ std::string roman = ""; std::size_t i = 0; while (number >= digits[i].arabic) { roman += digits[i].roman; number -= digits[i].arabic; } while (number >= digits[1].arabic) { roman += digits[1].roman; number -= digits[1].arabic; } while (number >= digits[2].arabic) { roman += digits[2].roman; number -= digits[2].arabic; } return roman;}



...std::string to_roman(int number){ std::string roman = ""; std::size_t i = 0; while (number >= digits[i].arabic) { roman += digits[i].roman; number -= digits[i].arabic; }

while (number >= digits[ ].arabic) { roman += digits[ ].roman; number -= digits[ ].arabic; } while (number >= digits[2].arabic) { roman += digits[2].roman; number -= digits[2].arabic; } return roman;}





i++i;

ii


variable.

...std::string to_roman(int number){ std::string roman = ""; std::size_t i = 0; while (number >= digits[i].arabic) { roman += digits[i].roman; number -= digits[i].arabic; } ++i; while (number >= digits[i].arabic) { roman += digits[i].roman; number -= digits[i].arabic; } while (number >= digits[2].arabic) { roman += digits[2].roman; number -= digits[2].arabic; } return roman;}


variable.


...std::string to_roman(int number){ std::string roman = ""; std::size_t i = 0; while (number >= digits[i].arabic) { roman += digits[i].roman; number -= digits[i].arabic; } ++i; while (number >= digits[i].arabic) { roman += digits[i].roman; number -= digits[i].arabic; }

while (number >= digits[ ].arabic) { roman += digits[ ].roman; number -= digits[ ].arabic; } return roman;}


variable.




++i;i

ii

Now I can collapse the duplication into

a for statement.

...std::string to_roman(int number){ std::string roman = ""; std::size_t i = 0; while (number >= digits[i].arabic) { roman += digits[i].roman; number -= digits[i].arabic; } ++i; while (number >= digits[i].arabic) { roman += digits[i].roman; number -= digits[i].arabic; } ++i; while (number >= digits[i].arabic) { roman += digits[i].roman; number -= digits[i].arabic; } return roman;}


a for statement.

...std::string to_roman(int number){ std::string roman = ""; std::size_t i = 0; while (number >= digits[i].arabic) { roman += digits[i].roman; number -= digits[i].arabic; } ++i; while (number >= digits[i].arabic) { roman += digits[i].roman; number -= digits[i].arabic; } ++i; while (number >= digits[i].arabic) { roman += digits[i].roman; number -= digits[i].arabic; } return roman;}

for ( i != 3; ++i)


a for statement.

...std::string to_roman(int number){ std::string roman = ""; for (std::size_t i = 0; i != 3; ++i) while (number >= digits[i].arabic) { roman += digits[i].roman; number -= digits[i].arabic; } ++i; while (number >= digits[i].arabic) { roman += digits[i].roman; number -= digits[i].arabic; } ++i; while (number >= digits[i].arabic) { roman += digits[i].roman; number -= digits[i].arabic; } return roman;}


a for statement.

...std::string to_roman(int number){ std::string roman = ""; for (std::size_t i = 0; i != 3; ++i) while (number >= digits[i].arabic) { roman += digits[i].roman; number -= digits[i].arabic; }

return roman;}


a for statement.

...std::string to_roman(int number){ std::string roman = ""; for (std::size_t i = 0; i != 3; ++i) while (number >= digits[i].arabic) { roman += digits[i].roman; number -= digits[i].arabic; } return roman;}



a for statement.


Now I can replace 3 with the size of the

array.

#include "to_roman.hpp"...const digit digits[] = { { 100, "C" }, { 10, "X" }, { 1, "I" }, };

std::string to_roman(int number){ std::string roman = ""; for (std::size_t i = 0; i != 3; ++i) while (number >= digits[i].arabic) { roman += digits[i].roman; number -= digits[i].arabic; } return roman;}


array.


std::string to_roman(int number){ std::string roman = ""; for (std::size_t i = 0; i != 3; ++i) while (number >= digits[i].arabic) { roman += digits[i].roman; number -= digits[i].arabic; } return roman;}

const std::size_t n = sizeof digits / sizeof digits[0];


array.



std::string to_roman(int number){ std::string roman = ""; for (std::size_t i = 0; i != ; ++i) while (number >= digits[i].arabic) { roman += digits[i].roman; number -= digits[i].arabic; } return roman;}


array.




n



array.




n

Excellent.

Done.#include "to_roman.hpp"


const digit digits[] = { { 100, "C" }, { 10, "X" }, { 1, "I" }, };


std::string to_roman(int number){ std::string roman = ""; for (std::size_t i = 0; i != n; ++i) while (number >= digits[i].arabic) { roman += digits[i].roman; number -= digits[i].arabic; } return roman;}

Done.#include "to_roman.hpp"





Anything else?






What do you see?






What do you see?

digits and n have internal linkage

because they are const, but the digit type has external

linkage.

How can I give a type internal

linkage?






How can I give a type internal

linkage?






With an anonymous namespace.





...

Can you Show me?





...

Like this.

Can you Show me?

Like this.





...

Can you Show me?

Like this.





...

namespace {

Can you Show me?

Like this.


namespace{ struct digit { int arabic; std::string roman; };



...

Can you Show me?

Like this.





...}

Can you Show me?

Like this.





...}


Can you Show me?


namespace{...}


Anything else?


namespace{...}


Anything else?

roman += roman statement suggests renaming number

to arabic.


namespace{...}


Anything else?


to arabic.


namespace{...}

std::string to_roman(int ){ std::string roman = ""; for (std::size_t i = 0; i != n; ++i) while ( >= digits[i].arabic) { roman += digits[i].roman; -= digits[i].arabic; } return roman;}


namespace{...}


Anything else?


to arabic.


namespace{...}


arabic

arabic

arabic


namespace{...}



Anything else?


to arabic.


namespace{...}


arabic

arabic

arabic

Here's our tests. #include "to_roman.hpp"#include <cassert>#include <iostream>...static void test_to_roman(){ assert_to_roman( 1, "I"); assert_to_roman( 2, "II"); assert_to_roman( 3, "III"); assert_to_roman( 10, "X"); assert_to_roman( 20, "XX"); assert_to_roman( 30, "XXX"); assert_to_roman( 33, "XXXIII"); assert_to_roman(100, "C");}

Here's our tests. #include "to_roman.hpp"#include <cassert>#include <iostream>...static void test_to_roman(){ assert_to_roman( 1, "I"); assert_to_roman( 2, "II"); assert_to_roman( 3, "III"); assert_to_roman( 10, "X"); assert_to_roman( 20, "XX"); assert_to_roman( 30, "XXX"); assert_to_roman( 33, "XXXIII"); assert_to_roman(100, "C");}

I think 200 and 300 should pass.

Here's our tests.

333 too.

#include "to_roman.hpp"#include <cassert>#include <iostream>...static void test_to_roman(){ assert_to_roman( 1, "I"); assert_to_roman( 2, "II"); assert_to_roman( 3, "III"); assert_to_roman( 10, "X"); assert_to_roman( 20, "XX"); assert_to_roman( 30, "XXX"); assert_to_roman( 33, "XXXIII"); assert_to_roman(100, "C");}


Here's our tests.

333 too.



#include "to_roman.hpp"#include <cassert>#include <iostream>...static void test_to_roman(){ assert_to_roman( 1, "I"); assert_to_roman( 2, "II"); assert_to_roman( 3, "III"); assert_to_roman( 10, "X"); assert_to_roman( 20, "XX"); assert_to_roman( 30, "XXX"); assert_to_roman( 33, "XXXIII"); assert_to_roman(100, "C");

}

Here's our tests.

333 too.




}

assert_to_roman(200, "CC"); assert_to_roman(300, "CCC"); assert_to_roman(333, "CCCXXXIII");

Here's our tests.

333 too.





}


Here's our tests.

333 too.





}

assert_to_roman(200, "CC"); assert_to_roman(300, "CCC"); assert_to_roman(333, "CCCXXXIII");Excellent.

We've got duplication in our tests. Let's refactor them.

#include "to_roman.hpp"#include <cassert>#include <iostream>...static void test_to_roman(){ assert_to_roman( 1, "I"); assert_to_roman( 2, "II"); assert_to_roman( 3, "III"); assert_to_roman( 10, "X"); assert_to_roman( 20, "XX"); assert_to_roman( 30, "XXX"); assert_to_roman( 33, "XXXIII"); assert_to_roman(100, "C"); assert_to_roman(200, "CC"); assert_to_roman(300, "CCC"); assert_to_roman(333, "CCCXXXIII");}



I think it's questionable whether

the duplication in these tests is worth

refactoring.



I think it's questionable whether

the duplication in these tests is worth

refactoring.

Let's try it and see if we think it's better.

I'll create an int string struct just like before...




#include "to_roman.hpp"#include <cassert>#include <iostream>...

static void test_to_roman(){ assert_to_roman( 1, "I"); assert_to_roman( 2, "II"); assert_to_roman( 3, "III"); assert_to_roman( 10, "X"); assert_to_roman( 20, "XX"); assert_to_roman( 30, "XXX"); assert_to_roman( 33, "XXXIII"); assert_to_roman(100, "C"); assert_to_roman(200, "CC"); assert_to_roman(300, "CCC"); assert_to_roman(333, "CCCXXXIII");}



#include "to_roman.hpp"#include <cassert>#include <iostream>...


struct test_data{ int arabic; std::string roman;};

Now I'll create an array of them. I'll just

do two to start.

#include "to_roman.hpp"#include <cassert>#include <iostream>...struct test_data{ int arabic; std::string roman;};



do two to start.






do two to start.





const test_data tests[] ={ { 1, "I" }, { 2, "II" },};

Now I'll use the array.










int main(){

test_to_roman(); std::cout << "All tests passed" << std::endl;}







int main(){


for (size_t i = 0; i != 2; ++i) assert_to_roman( tests[i].arabic, tests[i].roman);







int main(){




I'll get rid of the magic number 2.



int main(){ for (size_t i = 0; i != 2; ++i) assert_to_roman( tests[i].arabic, tests[i].roman);









int main(){










int main(){



const size_t n = sizeof tests / sizeof tests[0];








int main(){




n;

I'll fill in the rest of the array.


const test_data tests[] ={ { 1, "I" }, { 2, "II" },};...





const test_data tests[] ={ { 1, "I" }, { 2, "II" },

};...






};...

{ 3, "III" }, { 10, "X" }, { 20, "XX" }, { 30, "XXX" }, { 33, "XXXIII" }, { 100, "C" }, { 200, "CC" }, { 300, "CCC" }, { 333, "CCCXXXIII" },







};...


Now I can delete test_to_roman() and

its call.

...const test_data tests[] ={ { 1, "I" }, ... { 333, "CCCXXXIII" },};

static void test_to_roman(){ assert_to_roman( 1, "I"); ... assert_to_roman(333, "CCCXXXIII");}

int main(){ const size_t n = sizeof tests / sizeof tests[0];

for (size_t i = 0; i != n; ++i) assert_to_roman( tests[i].arabic, tests[i].roman);



its call.






its call.






ok

Can you see anything else?

...struct test_data{ int arabic; std::string roman;};

const test_data tests[] ={ { 1, "I" }, ... { 333, "CCCXXXIII" },};




Can you see anything else?






Perhaps make assert_to_roman()

a method of test_data?

I agree. I'll change the call first.




for (size_t i = 0; i != n; ++i)


assert_to_roman( tests[i].arabic, tests[i].roman);

I agree. I'll change the call first.




for (size_t i = 0; i != n; ++i)


tests[i].assert_equal();

Now I'll add a declaration.



for (size_t i = 0; i != n; ++i) tests[i].assert_equal();



...struct test_data{ int arabic; std::string roman;

};





...struct test_data{ int arabic; std::string roman;

};




void assert_equal() const;

Now I'll rework the definition.

...struct test_data{ int arabic; std::string roman; void assert_equal() const;};

{ const std::string actual = to_roman(arabic); if (expected != actual) { std::cerr << "expected: to_roman" << '(' << arabic << ") == " << '"' << expected << '"' << std::endl; std::cerr << " actual: to_roman" << '(' << arabic << ") == " << '"' << actual << '"' << std::endl; assert(false); }}

static void assert_to_roman(int arabic, const std::string & expected)




void test_data::assert_equal() const

I need to rename

roman to expected.

...struct test_data{ int arabic; std::string void assert_equal() const;};

void test_data::assert_equal() const{ const std::string actual = to_roman(arabic); if (expected != actual) { std::cerr << "expected: to_roman" << '(' << arabic << ") == " << '"' << expected << '"' << std::endl; std::cerr << " actual: to_roman" << '(' << arabic << ") == " << '"' << actual << '"' << std::endl; assert(false); }}

roman;

I need to rename

roman to expected.



I need to rename

roman to expected.



expected;

I need to rename

roman to expected.



expected;


ok

Anything else?

Anything else?

The name test_data is a bit weak.

Anything else?


And it should not have external linkage.

Anything else?


Agreed.


Anything else?


Agreed.


But we can come back to that later.

Let's compare the tests before and after the

refactoring

Let's compare the tests before and after the

refactoring

Yeah! I forgot about that.



Here's the tests before we

refactored them.



Its directness is quite elegant.

Here's the tests before we

refactored them.

...struct test_data{ int arabic; std::string expected; void assert_equal() const;};

const test_data tests[] ={ { 1, "I" }, { 2, "II" }, { 3, "III" }, { 10, "X" }, { 20, "XX" }, { 30, "XXX" }, { 33, "XXXIII" }, { 100, "C" }, { 200, "CC" }, { 300, "CCC" }, { 333, "CCCXXXIII" },};




Here's the tests after we refactored

them.

It feels quite different. And

there's more lines of code! I'm not sure

which I prefer.

...struct test_data{ int arabic; std::string expected; void assert_equal() const;};

const test_data tests[] ={ { 1, "I" }, { 2, "II" }, { 3, "III" }, { 10, "X" }, { 20, "XX" }, { 30, "XXX" }, { 33, "XXXIII" }, { 100, "C" }, { 200, "CC" }, { 300, "CCC" }, { 333, "CCCXXXIII" },};




Here's the tests after we refactored

them.

What now?

What now?

How about adding a test for 5 being V.

What now?

How about adding a test for 5 being V.

ok

I just have to add one more entry to the

tests array.

...const test_data tests[] ={ { 1, "I" }, { 2, "II" }, { 3, "III" }, { 10, "X" }, { 20, "XX" }, { 30, "XXX" }, { 33, "XXXIII" }, { 100, "C" }, { 200, "CC" }, { 300, "CCC" }, { 333, "CCCXXXIII" },};





tests array.

...const test_data tests[] ={ { 1, "I" }, { 2, "II" }, { 3, "III" },

{ 10, "X" }, { 20, "XX" }, { 30, "XXX" }, { 33, "XXXIII" }, { 100, "C" }, { 200, "CC" }, { 300, "CCC" }, { 333, "CCCXXXIII" },};





tests array.






{ 5, "V" },


tests array.






{ 5, "V" },

$ cc -Wall -Werror *.cpp && ./a.out$ cc -Wall -Werror *.cpp && ./a.outexpected: to_roman(5) == "V" actual: to_roman(5) == "IIIII"Assertion failed: (false), ...


tests array.







{ 5, "V" },

$ cc -Wall -Werror *.cpp && ./a.out$ cc -Wall -Werror *.cpp && ./a.outexpected: to_roman(5) == "V" actual: to_roman(5) == "IIIII"Assertion failed: (false), ...

Now to make it pass.

...namespace{




}

std::string to_roman(int arabic){ std::string roman = ""; for (std::size_t i = 0; i != n; ++i) while (arabic >= digits[i].arabic) { roman += digits[i].roman; arabic -= digits[i].arabic; } return roman;}


...namespace{




}


I just need to say the digit

5 is V.



5 is V.

...namespace{


const digit digits[] = { { 100, "C" }, { 10, "X" },

{ 1, "I" }, };


}




5 is V.

...namespace{



{ 1, "I" }, };


}


{ 5, "V" },



Excellent


5 is V.

...namespace{



{ 1, "I" }, };


}


{ 5, "V" },


Numbers like 6 and 338 should now pass.

...const test_data tests[] ={ { 1, "I" }, { 2, "II" }, { 3, "III" }, { 5, "V" }, { 10, "X" }, { 20, "XX" }, { 30, "XXX" }, { 33, "XXXIII" }, { 100, "C" }, { 200, "CC" }, { 300, "CCC" }, { 333, "CCCXXXIII" },};





Agreed.

...const test_data tests[] ={ { 1, "I" }, { 2, "II" }, { 3, "III" }, { 5, "V" }, { 10, "X" }, { 20, "XX" }, { 30, "XXX" }, { 33, "XXXIII" }, { 100, "C" }, { 200, "CC" }, { 300, "CCC" }, { 333, "CCCXXXIII" },};





Agreed.

...const test_data tests[] ={ { 1, "I" }, { 2, "II" }, { 3, "III" }, { 5, "V" },

{ 10, "X" }, { 20, "XX" }, { 30, "XXX" }, { 33, "XXXIII" }, { 100, "C" }, { 200, "CC" }, { 300, "CCC" }, { 333, "CCCXXXIII" },

};





Agreed.



};




{ 6, "VI" },

{ 338, "CCCXXXVIII" },


Agreed.




};




{ 6, "VI" },


Let's do 4 is IV now.


ok


ok

We already have 1 is I and 5 is V. Perhaps we could

somehow combine them to make IV.


ok



Hmmm...


ok



Hmmm...

I think it will get quite tricky.


ok



Hmmm...

I think it will get quite tricky.

Yes...

What are you thinking?


I'm thinking that when things get difficult it can be a sign that

you're doing it wrong.




We could just add a new 4 is IV entry in the digits array! It

seems like a hack though.






I think that's a great idea. I don't think it's a hack at all! It's the simplest thing that works.






I think that's a great idea. I don't think it's a hack at all! It's the simplest thing that works.

ok!

Here's the 4 is IV test.

...const test_data tests[] ={ { 1, "I" }, { 2, "II" }, { 3, "III" }, { 5, "V" }, { 6, "VI" }, { 10, "X" }, { 20, "XX" }, { 30, "XXX" }, { 33, "XXXIII" }, { 100, "C" }, { 200, "CC" }, { 300, "CCC" }, { 333, "CCCXXXIII" }, { 338, "CCCXXXVIII" },};



{ 5, "V" }, { 6, "VI" }, { 10, "X" }, { 20, "XX" }, { 30, "XXX" }, { 33, "XXXIII" }, { 100, "C" }, { 200, "CC" }, { 300, "CCC" }, { 333, "CCCXXXIII" }, { 338, "CCCXXXVIII" },};




{ 4, "IV" },


$ cc -Wall -Werror *.cpp && ./a.out$ cc -Wall -Werror *.cpp && ./a.outexpected: to_roman(4) == "IV" actual: to_roman(4) == "IIII"Assertion failed: (false), ...



{ 4, "IV" },


...namespace{


const digit digits[] = { { 100, "C" }, { 10, "X" }, { 5, "V" }, { 1, "I" }, };


}



...namespace{


const digit digits[] = { { 100, "C" }, { 10, "X" }, { 5, "V" }, { 1, "I" }, };


}



4 is IV.



4 is IV.

...namespace{


const digit digits[] = { { 100, "C" }, { 10, "X" }, { 5, "V" },

{ 1, "I" }, };


}




4 is IV.

...namespace{



{ 1, "I" }, };


}


{ 4, "IV" },




4 is IV.


...namespace{



{ 1, "I" }, };


}


{ 4, "IV" },



Excellent


4 is IV.


...namespace{



{ 1, "I" }, };


}


{ 4, "IV" },

We can repeat that idea for all the digits such as 9 being IX and 40 being XL.


Agreed.


Agreed.

So we've done it. It's just more of the same now.


Agreed.


Yes. I'm sure there'll be a few more small refactorings though. And we've an external linkage

todo from earlier.


Agreed.



todo from earlier.

Thanks for your help.


Agreed.



todo from earlier.

Thanks for your help.

Any time.

larry and jen do roman numerals in c++

Technology

string roman

return roman

roman letters

romanint number

roman numerals kata

roman numeral representation

positive integer number

leftmost digit