C / C++ / MFC

CLASS_I2CIO   i2c_ads1115_test(const char* DEVICE_I2C, int ADDRESS_ADS);

CPallini wrote:

I would keep it simple: an unsigned cannot be less than zero, full stop.

Member 14088880 wrote:

So implicitly an unsigned int is not capable of an access violation Below / before an array's first element given the pointer arithmetic. All that being said it does not seem at all necessary to test it.

void myfunction(int array[], unsigned int count)
{
    for (unsigned x = 0; x < count; x++)
        ...
}

myfunction(array, -1);

#include <stdio.h>

//void print_iterator(int integer_array[], int index)
void print_iterator(int integer_array[], unsigned int index)
{
	unsigned int i;

	if(index < 0)
	{
		printf("Index violation!\n");
		return;
	}
	else
		printf("Passed index validation: %d, as %u\n", index, index);

	for(i = 0; i < index; i++)
	{
//		printf("%d\t", integer_array[i]);

		if(i == 20)
		{
			printf("Loop overrun, undefined behavior\n");
			return;
		}
	}
}

main()
{
	int ints[] = { 1, 2, 3, 4, 5, 6, 7, 8 };
 
	print_iterator(ints, -1);
}

Quote:

Passed index validation: -1, as 4294967295
Loop overrun, undefined behavior
Press any key to continue . . .

Quote:

Index violation!
Press any key to continue . . .

Member 14088880 wrote:

If the index argument is declared as an unsigned int, it seems it will ALWAYS pass the bounds check when -1 is passed as the parameter...

Member 14088880 wrote:

If it is declared as an int (uncomment the first function line, comment out the second one) it will work properly:

void print_iterator(int integer_array[], size_t integer_array_len, size_t index)

print_iterator(ints, sizeof(ints) / sizeof(int), (size_t) -1);

leon de boer wrote:

What you are ignoring is the code is invalid and would fail any software audit .. you handed that junk to me and I would sack you.

leon de boer wrote:

What you are ignoring if you turn the compiler warning levels to max then your code won't compile .. it will give you a fatal error. At half-arse programmer wannabe settings it probably just gives you a warning about passing a signed integer into an unsigned integer interface.

Quote:

warning C4245: 'function' : conversion from 'int' to 'unsigned int', signed/unsigned mismatch

leon de boer wrote:

However in the real commercial world you run the compiler settings max and your code must not invoke any warning at all. Any good university when you submit your code for evaluation will have the compiler set to max you generate a warning you fail.

//Declare an int and unsigned int, initialize to -1, check bit representation:

//int int_neg_1 = -1;
11111111111111111111111111111111

//unsigned int uint_neg_1 = -1;
11111111111111111111111111111111

//Cast the unsigned int to int, check representation:
(int)uint_neg_1;
11111111111111111111111111111111

//Compare printf as signed and unsigned int for all three:

int_neg_1 : %d: -1, %u: 4294967295
uint_neg_1: %d: -1, %u: 4294967295
(int)uint_neg_1: %d: -1, %u: 4294967295

//This is the thing that caught me off guard.  "uint_neg_1 < 0" does not evaluate to true.

int_neg_1       < 0: True
uint_neg_1      < 0: False

//If however, I cast the unsigned int to "int" it seems to force interpretation as a signed number:
(int)uint_neg_1 < 0: True

Quote:

There is hence absolutely no point in testing an unsigned integer for being negative! It has no capacity of being negative!

/* code sample for demonstration and testing purposes */


#include <stdio.h>

#define print_binary(a) \
	for(j = 31; j >= 0; j--) \
		printf("%c", a & (1 << j) ? '1' : '0');	\
	printf("\n\n");											

void main()
{
	int j;

	int int_neg_1 = -1;
	unsigned int uint_neg_1 = -1;

	printf("int int_neg_1 = -1;\n");
	print_binary(int_neg_1);

	printf("unsigned int uint_neg_1 = -1;\n");
	print_binary(uint_neg_1);

	printf("(int)uint_neg_1;\n");
	print_binary((int)uint_neg_1);


	printf("int_neg_1 : %%d: %d, %%u: %u\n", int_neg_1, int_neg_1);
	printf("uint_neg_1: %%d: %d, %%u: %u\n", uint_neg_1, uint_neg_1);
	printf("(int)uint_neg_1: %%d: %d, %%u: %u\n\n", (int)uint_neg_1, (int)uint_neg_1);


	printf("int_neg_1\t< 0: %s\n", int_neg_1 < 0 ? "True" : "False");
	printf("uint_neg_1\t< 0: %s\n\n", uint_neg_1 < 0 ? "True" : "False");

	printf("(int)uint_neg_1\t< 0: %s\n\n", (int)uint_neg_1 < 0 ? "True" : "False");
}

Member 14088880 wrote:

//This is the thing that caught me off guard. "uint_neg_1 < 0" does not evaluate to true.

#include <stdio.h>
#include <stdlib.h>
#include <time.h>

//Paul writes this code
int get_available_seat_count(unsigned int *seating_counts, unsigned int row_index, unsigned int num_rows, unsigned int seats_per_row)
{
	if(row_index < 0)
	{
		printf("row_index < 0: TRUE\n");
		return -1;
	}
	else
		printf("row_index < 0: FALSE\n");

//preferable method?:
	if(&seating_counts[row_index] < &seating_counts[0])
		printf("Array minimum boundary violation, index is %d\n", row_index);

	if(&seating_counts[row_index] > &seating_counts[num_rows-1])
		printf("Array maximum boundary violation, index is %d\n", row_index);

	return seats_per_row - seating_counts[row_index];
}

//Peter writes this code
void main()
{
	//row 0 is the back of the theater, row[num_rows-1]  is at the stage
	int num_rows = 12;
	int seats_per_row = 40;
	int n_available_seats;
	int row_index;
	unsigned int seating_counts[12];
	int i;

	//set the current state of the theater:
	srand((int)time(NULL));
	for(i = 0; i < num_rows; i++)
		seating_counts[i] = (unsigned int)rand() % seats_per_row;

	printf("Customer: are there any seats available in the third row from the stage?\n\n");
	row_index = 3;

	//rows are stored in reverse order from customer request, subtract row_index to get offset
	n_available_seats = get_available_seat_count(seating_counts, row_index - num_rows, num_rows, seats_per_row);

	printf("\nTeller: there are %d seats available in that row\n", n_available_seats);
}

Quote:

Customer: are there any seats available in the third row from the stage?

row_index < 0: FALSE
Array minimum boundary violation, index is -9

Teller: there are 858993500 seats available in that row