Display Problem in C++ If Even Numbers is Inputted - c++

Question

i have a very simple problem when displaying the single "A". It should start on the RIGHT SIDE and not on the left. It is correct when i input odd numbers but if i input even numbers it outputs wrong.
I have to follow this guidelines by the way,
Guidelines:
Pointers and references must be used to display the values.
displayRoad runs recursively.
Loop statements are not allowed
Object instance must be destroyed after use.
Pls see the pictures below:
WRONG RESULT (EVEN NUMBERS)
CORRECT RESULT (ODD NUMBERS)
CODE
#include <iostream>
#include <string>
using namespace std;
class myRoad
{
private:
char myChar;
int myH, myW;
public:
myRoad(){
askChar();
askHeight();
askWidth();
}
void askChar();
void askHeight();
void askWidth();
void recurs_W(char c, int w, int h);
void recurs_H(char c, int h, int w);
char getChar(){return myChar;}
int getHeight(){return myH;}
int getWidth(){return myW;}
};
void displayRoad(myRoad* mRoad);
int main()
{
myRoad* mRoad = new myRoad();
cout << endl << endl;
displayRoad(mRoad);
delete mRoad;
}
void displayRoad(myRoad* mRoad)
{
mRoad->recurs_H(mRoad->getChar(),mRoad->getHeight() * 2 + 1, mRoad->getWidth());
}
void myRoad::askChar()
{
char ch;
cout << "Enter a character: ";
cin >> ch;
myChar = ch;
}
void myRoad::askHeight()
{
int h = 0;
cout << "Enter height: ";
cin >> h;
myH = h;
}
void myRoad::askWidth()
{
int w = 0;
cout << "Enter width: ";
cin >> w;
myW = w;
}
void myRoad::recurs_H(char c, int h, int w)
{
if(h == 0)
return;
recurs_W(c, w, h);
recurs_H(c, --h,w);
}
void myRoad::recurs_W(char c, int w, int h)
{
if(w == 0)
{
cout << endl;
return;
}
else
{
if(h % 2 == 1)
cout << myChar;
else
{
if (w == myW && h % 4 == 0)
{
cout << myChar;
}
else if (w == 1 && h % 2 == 0 && h % 4 != 0)
{
cout << myChar;
}
else
cout << ' ';
}
}
return recurs_W(c, --w, h);
}

Answer 1

You choose whether to put the character on the right or left, depending on whether h is odd or even.
So, it is not surprising that making h start as an odd number (rather than an even one) should reverse that choice for the first step.
I propose you introduce a new variable i, that instead of going 10→0 (or 5→0), goes 0→10 (or 0→5).
(I'm ignoring one-based indexing and exclusive ranges in the above numerical examples, but you get the point)
Then make your left-or-right decision based on i instead of h, as it'll always start as even (0).
This variable would begin at zero and be incremented every time h is decremented, so it's the exact mirror.
You don't actually need to store i anywhere; you can just calculate it when needed:
int myRoad::currentRowNumber(int h)
{
return getHeight() - h;
}
Then instead of, say, h % 2, you do currentRowNumber(h) % 2.
There are simpler ways to achieve the wider goal, but this is a quick fix that demonstrates the cause of the problem.

Answer 2

Best thing you can do is converting your algorithm into an iterative one:
for(int i = 0; i < myH; ++i)
{
for(int j = 0; j < myW; ++j)
std::cout << 'A';
std::cout << '\n';
if((i & 1) == 0)
{
for(int j = 1; j < myW; ++j)
std::cout << ' ';
}
std::cout << "A\n";
}
if(myH != 0) // drop, if you want to have a single line for height = 0
{
// final line:
for(int i = 0; i < myW; ++i)
std::cout << 'A';
std::cout << std::endl; // in contrast to simple '\n', std::endl flushes the output
// stream as well, assuring user sees output immediately
}
If you insist on a recursive variant (be aware that you might suffer from stack overflow pretty quickly for larger widths and heights!): The problem is that you decide by remaining height, not current height, if you want to draw the A on left or right. That reverses your structure in vertical direction. As for odd numbers the structure is axially symmetric, you won't notice, though, but with even numbers, you get bitten.
You could fix that, for instance by providing an additional parameter indicating current height, which iterates from 0 to maximum height:
void myRoad::recurs_H(char c, int h, int w)
{
if(h < myH)
{
recurs_W(c, w, h);
recurs_H(c, ++h, w);
// ^^ (!)
}
}
with initial call as:
recurs_H('A', 0, myW);
// ^ (!)
I personally recommend re-organising the functions, though:
void myRoad::recurs_W(char c, int w)
{
if(w < myW)
{
std::cout << c;
recurse_W(c, w + 1);
}
}
void myRoad::recurs_H(char c, int h)
{
if(h < myH)
{
recurse_W(c, 0);
std::cout << '\n';
if((h & 1) == 0)
recurs_W(' ', 1);
std::cout << c << '\n';
recurs_H(c, h + 1);
}
}
void displayRoad(myRoad* mRoad)
{
if(mRoad->getWidth() && mRoad->getHeight())
{
mRoad->recurs_H(mRoad->getChar(), 0);
// draw the final line
mRoad->recurs_W(mRoad->getChar(), 0);
std::cout << std::endl;
}
}
See how much this resembles the iterative variant? See how far less complicated the recurse_W function got? Additionally, as you don't need the value of the member variable any more after the recursive call (the recursive call is the very last thing you do!), you can profit from tail call optimisation, which will prevent your stack from growing...
Negative width or height is pretty meaningless, isn't it? So you might consider changing the type to unsigned (and the recursive function parameters as well). Careful, though, when downcounting – people tend to overlook that unsigned numbers cannot get negative:
for(unsigned int n = 7; n >= 0; --n)
results in endless loop. But that's actually easily covered:
for(unsigned n = 8; n-- > 0; )
or, if you consider that unsigned overflows:
for(unsigned n = 7; n <= 7; --n)