Prev: VS2008 Editor Freezes, Can only add text, not remove ???
Next: i need help
From: TheDevil on 12 Apr 2008 02:06
Hello,

First of all I already found one or two IDE bugs depending on how one looks
at it:

1. Freezing of IDE
2. Unable to rename folder because IDE hanging in tasklist.

Anyway.

Lesson 3: Integer Assignments, Signed to Unsigned with Mixed Sizes.

This lesson is pretty interesting.

It surprised me a couple of times.

See interesting resulting numbers.

This is awesome test to Kill Students during Exams.

Alternative/better way to get the source below:

http://members.home.nl/hbthouppermans/VS2008Analysis/Index.htm

// *** Begin of Main.cpp ***

#include <stdio.h>

typedef char int8;
typedef short int int16;
typedef int int32;
typedef long long int64;

typedef unsigned char uint8;
typedef unsigned short uint16;
typedef unsigned int uint32;
typedef unsigned long long uint64;

/*

12 april 2008

Back to School:

Lesson 3, Integer Assignments, Signed to Unsigned with Mixed Sizes.

Conclusions:

Bad: No warnings for extreme negative int-to-uint conversions.

39 out of 48 tests OK
9 out of 48 tests BAD

Score:

8.125 out of 10

10 out of 48 tests INTERESTING

Interesting Resulting Numbers:
128,
65408,
4294967168,
4294934528,
4294967295,
18446744073709551488,
18446744073709518848,
18446744071562067968

*/

int main()
{
printf("Program Started \n\n");

int8 vMinInt8;
int8 vMaxInt8;

uint8 vMinUint8;
uint8 vMaxUint8;

int16 vMinInt16;
int16 vMaxInt16;

uint16 vMinUint16;
uint16 vMaxUint16;

int32 vMinInt32;
int32 vMaxInt32;

uint32 vMinUint32;
uint32 vMaxUint32;

int64 vMinInt64;
int64 vMaxInt64;

uint64 vMinUint64;
uint64 vMaxUint64;

int8 vInt8;
uint8 vUint8;

int16 vInt16;
uint16 vUint16;

int32 vInt32;
uint32 vUint32;

int64 vInt64;
uint64 vUint64;

// setup min and max for int8
vMinInt8 = -128;
vMaxInt8 = 127;

// setup min and max for uint8
vMinUint8 = 0;
vMaxUint8 = 255;

// setup min and max for int16
vMinInt16 = -32768;
vMaxInt16 = 32767;

// setup min and max for uint16
vMinUint16 = 0;
vMaxUint16 = 65535;

// setup min and max for int32
vMinInt32 = 2147483648; // same as -2147483648, solves warning, <-
weakness in language.
vMaxInt32 = 2147483647;

// setup min and max for uint32
vMinUint32 = 0;
vMaxUint32 = 4294967295;

// setup min and max for int64
vMinInt64 = 9223372036854775808; // same as -9223372036854775808, solves
warning, <- weakness in language
vMaxInt64 = 9223372036854775807; // 9223372036854775808 would give no
warning ?!?!, BAD

// test min and max for uint64
vMinUint64 = 0;
vMaxUint64 = 18446744073709551615;

// test doubtfull assignments, like mixing types and/or sizes.

// unsigned 8 bit = negative signed variable bit
// TEST 1
// vUint8 = vMinInt8; // no warning, BAD.
// result: 128, OK, INTERESTING

// TEST 2
// vUint8 = -100; // warning: conversion from 'int' to 'uint8',
signed/unsigned mismatch, OK
// BUT INCONSISTENT with above

// TEST 3
// vUint8 = vMaxInt8; // no warning, OK
// // result: 127, OK

// TEST 4
// vUint8 = vMinInt16; // warning: conversion from 'int16' to 'uint8',
possible loss of data, OK
// result: 0, OK

// TEST 5
// vUint8 = -10000; // warning: conversion from 'int' to 'uint8',
signed/unsigned mismatch, OK

// TEST 6
// vUint8 = vMaxInt16; // warning: conversion from 'int16' to
'uint8', possible loss of data, OK
// // result: 255, OK

// TEST 7
// vUint8 = vMinInt32; // warning: conversion from 'int32' to 'uint8',
possible loss of data, OK
// // result: 0, OK

// TEST 8
// vUint8 = -1000000; // warning: conversion from 'int' to 'uint8',
signed/unsigned mismatch, OK

// TEST 9
// vUint8 = vMaxInt32; // warning: conversion from 'int32' to 'uint8',
possible loss of data, OK
// result: 255, OK

// TEST 10
// vUint8 = vMinInt64; // warning: conversion from 'int64' to 'uint8',
possible loss of data, OK
// // result: 0, OK

// TEST 11
// vUint8 = -100000000000; // warning: conversion from '__int64' to
'uint8', signed/unsigned mismatch, OK

// TEST 12
// vUint8 = vMaxInt64; // warning: conversion from 'int64' to 'uint8',
possible loss of data, OK
// result: 255, OK

// printf( "vUint8: %u \n", vUint8 );

// unsigned 16 bit = negative signed variable bit

// TEST 13
// vUint16 = vMinInt8; // no warning, BAD
// result: 65408, OK, INTERESTING

// TEST 14
// vUint16 = -100; // warning: conversion from 'int' to 'uint16',
signed/unsigned mismatch, OK

// TEST 15
// vUint16 = vMaxInt8; // no warning, OK
// result: 127, OK

// TEST 16
// vUint16 = vMinInt16; // no warning, BAD
// // result: 32768, OK

// TEST 17
// vUint16 = -1000; // warning: conversion from 'int' to 'uint16',
signed/unsigned mismatch, OK

// TEST 18
// vUint16 = vMaxInt16; // no warning, OK
// result: 32767, OK

// TEST 19
// vUint16 = vMinInt32; // warning: conversion from 'int32' to 'uint16',
possible loss of data, OK
// result: 0, OK

// TEST 20
// vUint16 = -1000000; // warning: conversion from 'int' to 'uint16',
signed/unsigned mismatch, OK

// TEST 21
// vUint16 = vMaxInt32; // warning: conversion from 'int32' to 'uint16',
possible loss of data, OK.
// result: 65535, OK

// TEST 22
// vUint16 = vMinInt64; // warning: conversion from 'int64' to 'uint16',
possible loss of data, OK
// result: 0, OK

// TEST 23
// vUint16 = -100000000000; // warning: conversion from '__int64' to
'uint16', signed/unsigned mismatch, OK

// TEST 24
// vUint16 = vMaxInt64; // warning: conversion from 'int64' to 'uint16',
possible loss of data, OK
// result: 65535, OK

// printf( "vUint16: %u \n", vUint16 );

// unsigned 32 bit = negative signed variable bit

// TEST 25
// vUint32 = vMinInt8; // no warning, BAD
// // result: 4294967168, OK, INTERESTING

// TEST 26
// vUint32 = -100; // conversion from 'int' to 'uint32', signed/unsigned
mismatch, OK

// TEST 27
// vUint32 = vMaxInt8; // no warning, OK
// result: 127, OK

// TEST 28
// vUint32 = vMinInt16; // no warning, BAD
// result: 4294934528, OK, INTERESTING

// TEST 29
// vUint32 = -10000; // conversion from 'int' to 'uint32',
signed/unsigned mismatch, OK

// TEST 30
// vUint32 = vMaxInt16; // no warning, OK
// result: 32767, OK

// TEST 31
// vUint32 = vMinInt32; // no warning, BAD
// result: 2147483648, OK

// TEST 32
// vUint32 = -1000000; // warning: conversion from 'int' to 'uint32',
signed/unsigned mismatch, OK

// TEST 33
// vUint32 = vMaxInt32; // no warning, OK
// result: 2147483647, OK

// TEST 34
// vUint32 = vMinInt64; // warning: conversion from 'int64' to 'uint32',
possible loss of data, OK
// result: 0, OK

// TEST 35
// vUint32 = -100000000000; // warning: conversion from '__int64' to
'uint32', signed/unsigned mismatch, OK

// TEST 36
// vUint32 = vMaxInt64; // warning: conversion from 'int64' to 'uint32',
possible loss of data, OK
// result: 4294967295, OK, AMAZINGLY INTERESTING

// printf( "vUint32: %u \n", vUint32 );

// unsigned 64 bit = negative signed variable bit

// TEST 37
// vUint64 = vMinInt8; // no warning, BAD
// result: 18446744073709551488, OK, INTERESTING

// TEST 38
// vUint64 = -100; // warning: conversion from 'int' to 'uint64',
signed/unsigned mismatch

// TEST 39
// vUint64 = vMaxInt8; // no warning, OK
// result: 127, OK

// TEST 40
// vUint64 = vMinInt16; // no warning, BAD
// result: 18446744073709518848, OK, INTERESTING

// TEST 41
// vUint64 = -10000; // warning: conversion from 'int' to 'uint64',
signed/unsigned mismatch, OK

// TEST 42
// vUint64 = vMaxInt16; // no warning, OK
// result: 32767, OK, AMAZINGLY INTERESTING

// TEST 43
// vUint64 = vMinInt32; // no warning, BAD
// result: 18446744071562067968, OK, INTERESTING

// TEST 44
// vUint64 = -1000000; // warning: conversion from 'int' to 'uint64',
signed/unsigned mismatch, OK

// TEST 45
// vUint64 = vMaxInt32; // no warning: OK
// result: 2147483647, OK

// TEST 46
// vUint64 = vMinInt64; // no warning, BAD
// result: 9223372036854775808, OK

// TEST 47
// vUint64 = -100000000000; // warning: conversion from '__int64' to
'uint64', signed/unsigned mismatch, OK

// TEST 48
// vUint64 = vMaxInt64; // no warning, OK, INTERESTING
// result: 9223372036854775807, OK

// printf("vUint64: %llu \n", vUint64 );

printf("Program finished \n");
}

// *** End of Main.cpp ***

Bye,
The Devil.


 | 
Pages: 1
Prev: VS2008 Editor Freezes, Can only add text, not remove ???
Next: i need help