C / C++ / MFC

CLASS_I2CIO(char Device, int Address);

class C_VNA {
   C_VNA();
   ...
   CLASS_I2CIO   i2c_ads1115_test; // just declaring the type of the member variable here
};
...
// constructors
// initialize the class members here (only needed when not using default constructor)
C_VNA::C_VNA()
 : i2c_ads1115_test(DEVICE_I2C,ADDRESS_ADS) 
{
   // more initialization code
}

Stefan_Lang wrote:

had to remove tags - for some reason they are not working!?

Vaclav_ wrote:

The error "points " to #define which is redefined in this class - temporary for test purposes.

#include "spi.h" // #defines DEVICE_SPI, etc

 #define DEVICE_SPI_"dev/spidev0.0" // Temporary define 

class C_VNA {
    // ...
};

#ifdef DEVICE_SPI
#define ORIG_DEVICE_SPI DEVICE_SPI
#undef DEVICE_SPI
#endif
#define DEVICE_SPI "dev/spidev0.0"
// your code here that uses the temporary DEVICE_SPI

#ifdef ORIG_DEVICE_SPI
#undef DEVICE_SPI
#define DEVICE_SPI ORIG_DEVICE_SPI
#undef  ORIG_DEVICE_SPI
#endif

CLASS_I2CIO   i2c_ads1115(DEVICE_I2C,ADDRESS_ADS);

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.