C / C++ / MFC

//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

Vaclav_ wrote:

Would assigning it outside the function defeat the "scope" of the class?

class Vector3i {
private:
   std::array<int,3> data;
public:
   // example 1: change own member variable
   void fill(const int value) {
      data.fill(value);
   }
   // example 2: change member variable from another instance
   void swap(Vector3i& other) {
      std::swap(data, other.data);
   }
};

1. There is no way to know whether the representation is 1 bit/value or 1 byte/value (this is a quality of implementation issue)
2. There is no way to know whether the underlying type is an array of chars, ints, or some other type
3. There is no way to know whether bit 0 is the MSB or the LSB of the underlying type

struct  op_status {
    unsigned int  status_1:2;
    unsigned int  status_2:2;
    unsigned int  error:6;
};

int devfd = open("/dev/a_device", O_RDWR);

struct op_status i2c_status;

read(devfd, &i2c_status, sizeof(i2c_status));

if(i2c_status.status_1 == 1) {
    /* do something */
} else if ( i2c_status.status_1 == 2 && i2c_status.status_2 = 1) {
    switch(i2c_status.error) {
        case 1:  /* handle error code 1 */
            break;
        case 2:  /* handle error code 2 */
            break;
        ...
        default: /* do something else */
    }
}

k5054 wrote:

looking a <bitset>, I don't see a nice way to group the bits together to treat them as a single unit, like you can using bit-fields.