Kind of off topic c programming question.

[Overyourhead]

Sorry if this is off topic, as it is not directly related to FIRST. I've recently started my intro to C programming class.One of my assignments is to write a program that will take 3 number inputs from the user and find the highest and lowest number of the three. I'm only working on the highest number right now.

I've gotten stuck where I am, maybe you guys can help me. Heres what I have so far. Thanks

#include "stdafx.h"


int _tmain(int argc, _TCHAR* argv[])
{
int input_1, /*Input from integer 1*/
input_2, /*Input from integer 2*/
input_3, /*Input from integer 3*/
high_value; /* Highest Value */


/* Collect integers from the user. */

printf("Please enter your first number:");
scanf("%d", &input_1);
printf("Please enter your second number:");
scanf("%d", &input_2);
printf("Please enter your third number:");
scanf("%d", &input_3);

/* Find the largest number *'


if (input_1 >= input_2 && input_1 >= input_3) {
high_value = input_2;

}
else if (input_2 >= input_2 && input_2 >= input_3) {
high_value = input_2;
}

else if (input_3 >= input_1 && input_3 >= input_2) {
high_value = input_3;
}



/*Display the highest and lowest numbers*/
printf("\n\nThe Largest number is %d. \n",&high_value);




return 0;
}

[basicxman]

I'm not going to give you code as this is for a school assignment however why not trying looping through the numbers and comparing against the upper and lower bound.

Assign the high value and low value variables to a null value
Loop through each input
Check if the high value is null, if so assign the input to the high value
Check if the low value is null, if so assign the input to the low value
If the lower/upper bounds are not null...
set the high value to the input if the input is greater than the current high value
set the low value to the input if the input is lower than the current low value

Take some time to think over the problem - flowcharts are always helpful.

You also have a few errors in your program...slow down, look at your code. Debugging is an art.

I'll give you a few tips:
Watch for typos - I see an invalid comment
Watch your assignments - looking at the main structure of your code where it compares the numbers, I see an incorrect assignment.

Plus when posting code on the forum please use [ CODE ][ /CODE ] (without spaces). Good luck!

[Branden Ghena]

Well, from what I can see you have a basic logic issue that probably comes from a series of typos.

Here is your code (note problems in red):

/* Find the largest number *'


if (input_1 >= input_2 && input_1 >= input_3) {
high_value = input_2;

}
else if (input_2 >= input_2 && input_2 >= input_3) {
high_value = input_2;
}

else if (input_3 >= input_1 && input_3 >= input_2) {
high_value = input_3;
}

This is what the code was probably meant to be (note changes in green):

/* Find the largest number *'


if (input_1 >= input_2 && input_1 >= input_3) {
high_value = input_1;

}
else if (input_2 >= input_1 && input_2 >= input_3) {
high_value = input_2;
}

else if (input_3 >= input_1 && input_3 >= input_2) {
high_value = input_3;
}

Now, its worth noting that there is a more efficient way to find the highest if you think about it logically.

/* Find the largest number *'

high_value = input_1;

if (input_2 >= high_value) {
     high_value = input_2;
}

if (input_3 >= high_value) {
    high_value = input_3;
}

But that is not really important because your method should work just fine if the mistypes are corrected.

[rsisk]

Setup some test cases, try to cover all possibilities:

case 1st 2nd 3rd  expect
1    0   0   0     0
2    1   2   3     3
3    1   1   3     3
4    3   2   1     3
5    1   3   2     3
6    2   3   1     3
7    3   0   0     3
8    3   3   3     3
9    a   2   ?     not sure

Then run the test cases through your program mentally, i.e.,

Case 1

if (0 >= 0 && 0 >= 0)
     true, high_value = 0

Case 2

if (1 >= 2 && 2 >= 3)
     false    
else if (2 >= 2 && 2 >= 3)
          true       false
else if (3 >= 1 && 3 >= 2)
          true      true  high_value = 3

After case 2, you may see your typo in the second test where you compare input_2 to input_2

Run all your test cases and make sure get the results you expect.

Try to include edge conditions, like the case 1 and case 8, where you test upper and lower limits

Force error conditions with the unexpected, like case 9 where non numeric values are input

After all of this, see if you can simplify the code. For example, what if you were dealing with more than three input numbers? The code would get really complex really fast. Maybe there is a better way?
What whould happen if you set high_value to input_1, then compared high_value to input_2, if less, set high_value to input_2. Do the same for input_3.
You could further simplify by putting the values into a loop until an end condition occured.
As you can see, there is more than one way to approach the defined problem.

Hope that helps

[byteit101]

Originally Posted by basicxman

Plus when posting code on the forum please use [ CODE ][ /CODE ] (without spaces). Good luck!

or, even better, the [ PHP ] Tag (w/o spaces) Although meant for PHP, it (for the most part) correctly highlights C and C++ to some extent, and you can see an additional error: comments end with */ not *'

PHP Code:

#include "stdafx.h"


int _tmain(int argc, _TCHAR* argv[])
{
int input_1, /*Input from integer 1*/
input_2, /*Input from integer 2*/
input_3, /*Input from integer 3*/
high_value; /* Highest Value */


/* Collect integers from the user. */

printf("Please enter your first number:");
scanf("%d", &input_1);
printf("Please enter your second number:");
scanf("%d", &input_2);
printf("Please enter your third number:");
scanf("%d", &input_3);

/* Find the largest number *'


if (input_1 >= input_2 && input_1 >= input_3) {
high_value = input_2;

}
else if (input_2 >= input_2 && input_2 >= input_3) {
high_value = input_2;
}

else if (input_3 >= input_1 && input_3 >= input_2) {
high_value = input_3;
}



/*Display the highest and lowest numbers*/
printf("\n\nThe Largest number is %d. \n",&high_value);




return 0;
} 


[daltore]

Also, there's another bit of a small discrepancy here that you made logically, but doesn't actually work. First, a short description of pointers...

Pointers are basically variables that don't take up any space. They don't store data, they store a memory address that points to something that does store data. So if I had an unsigned character variable Var, and it had a value of 123, I could make a pointer Pnt of the same type (unsigned char), that wouldn't take up the full 8 bits of memory space, but would instead redirect the computer to read from wherever Var is stored. There are two things you have to deal with (and they get very tricky) when working with pointers; lvalues and rvalues.

lvalues (left values) are what you see on the left side of an equal sign, you're taking an actual quantity and telling the computer where to put it. The lvalue is just the address of the variable. rvalues (right values), are the actual quantity value that you're reading or putting into another variable. When working with pointers, you have to specify, because it changes whether you are reading or writing to the variable which it points to. You specify an address (lvalue) by an ampersand (&), and you specify the value (rvalue) as an asterisk (*).

This brings us to scanf. You call scanf as "scanf("%c", &Var);" This is because you're writing a value to Var, and you need to know where to put it. However, when you want to display the same variable with printf, it needs to know what it's showing, not where to look, so you use the rvalue, but there's no asterisk needed, because normal (non-pointer) variables are assumed to either be an rvalue or an lvalue depending on where they show up. As a parameter to a function (something in between parentheses, no joke intended), it's assumed you want to give that function data, so the computer assumes an rvalue. However, with scanf, you really want to know where to put the data, so you have to specify with an &. You don't for any other common function.

This was a long way of pointing out that you don't need an & in the printf() statement at the end. Trust me, I've made this mistake plenty of times. But the address is actually a really big number that's stored in the register, not memory, which is why you get such a weird and huge value (which is also different every time) if you try to read data from that. Otherwise, just slips and typos here and there, stuff every good programmer does every once in a while.

[EricS-Team180]

Originally Posted by basicxman

...slow down, look at your code. Debugging is an art.

...ahhh true wisdom basicxman!

I'll add a 2 word hint: bubble sort ...a classic approach to learn.

[TDohse]

Originally Posted by daltore

Pointers are basically variables that don't take up any space. They don't store data, they store a memory address that points to something that does store data. So if I had an unsigned character variable Var, and it had a value of 123, I could make a pointer Pnt of the same type (unsigned char), that wouldn't take up the full 8 bits of memory space, but would instead redirect the computer to read from wherever Var is stored.

Actually, pointers take up memory space just like any other variable. The size will vary depending on the architecture you're on. A pointer to a char might take 32 or 64 bits on a modern desktop system.

If you're curious, run this code:

char *fooPtr;
printf("fooPtr is %i bytes\n", sizeof(fooPtr));

[daltore]

Ah, I stand corrected. But the rest is correct, yes?

[Chris27]

Originally Posted by daltore

lvalues (left values) are what you see on the left side of an equal sign, you're taking an actual quantity and telling the computer where to put it. The lvalue is just the address of the variable. rvalues (right values), are the actual quantity value that you're reading or putting into another variable. When working with pointers, you have to specify, because it changes whether you are reading or writing to the variable which it points to. You specify an address (lvalue) by an ampersand (&), and you specify the value (rvalue) as an asterisk (*).

An l-value is not an address, but something that has an address. For example, assume x was declared as "int x". x is an l-value, however, &x is not (that would be an r-value as all numbers are). Conversely, if x was declared as "int * x", both x and *x are l-values. For me it's easiest to think of l-values as anything that can be placed to the left of an '=' and r-values as anything that cannot.

[daltore]

An l-value is not an address, but something that has an address. For example, assume x was declared as "int x". x is an l-value, however, &x is not (that would be an r-value as all numbers are). Conversely, if x was declared as "int * x", both x and *x are l-values. For me it's easiest to think of l-values as anything that can be placed to the left of an '=' and r-values as anything that cannot.

Well what do you know, you're right. I should really work with pointers more often, I've been out of practice for a few months. I'm just going to stop talking now.

[slavik262]

The sad thing is after you do these silly sorting assignments you find that qsort() is built into the standard library. :/