Kind of off topic c programming question.

[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!

[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.

[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. :/

[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.