CSDGN Tale of the Lazy Programmer.

Things I miss in Java and C++

What I miss from C++
There are a handful of things I honestly miss in Java. Mostly because I am a bit twiddler.

For example, this fun bit of C++. The only way to do this in java is big and messy and slow, for multiple reasons. Java lacks anything that allows the simple automatic memory sharing behavior this shows, you have to convert between types. This is mostly because of Java’ type safety. I sigh and say, “OKAY, fine, that just how you are, you are very type safe, this is the result.” However, there is something else, which Java doesn’t have an excuse to not have! Unsigned types, honestly. How hard is it to add unsigned types, unsigned types are useful, for far more reasons than something like this. Almost every network protocol in the whole of existence uses unsigned data. Usually data in most binary data formats are unsigned. I guess they didn’t expect people writing in this to access the filesystem, use a network. I guess that is possible. Maybe they didn’t think anyone who used Java would ever want to have unsigned data (wrong, as you can see by my case).

"The omission of unsigned integral types from Java is somewhat controversial, but they are in fact inessential, if perhaps convenient nonetheless."

Convenient, definitely, inessential, somewhat so, Unwanted, definitely not.

//C++
struct {
	union {
		union {
			uint16_t r16_1;
			struct {
				uint8_t r8_1;
				uint8_t r8_2;
			};
		};
		union {
			uint16_t r16_2;
			struct {
				uint8_t r8_3;
				uint8_t r8_4;
			};
		};
		uint32_t r32_1;
	};
} registers;

For you who are not in the know, when it comes to C++, union basically allows you to share memory between two variables. This is useful for many things, but the above is what I use it for the most. What it does in this case, because they are anonymous unions and structs, allows me to share memory between the 8′s the 16′s and the 32, so changing one would change the ones that are built on top of it, or under it. Changing r8_1 would change r16_1 and r32_1, but changing r16_1 could only change r32_1 and r8_1/r8_2. Which allows me to do fancy stuff.

registers.r8_1 = 0xF;
registers.r8_2 = 0x1F;
printf("%04X", registers.r16_1);

Would produce “1F0F”. This is pretty straight forward in this case but this next one is less so.

registers.r8_2 = 3 << 2;
registers.r16_1 = registers.r16_1 >> 3;
registers.r8_1 = registers.r8_2 << 1;
printf("%04X", registers.r16_1);

What does this produce? Can you even begin to guess? I can but I have been doing this a long time. It produces “0102″, or 0×0102. We put 0x0C into r8_2 which makes it 0x0C00, rightshift 3, puts one bit over the byte border, so now r8_2 is only 0×1, and r8_1 is 0×80. But we take that 1 in r8_2 and left shift it 1 and assign that to our r8_1, which becomes 2.

Another thing I miss from C++ is the numerated enumerations.

enum {
	a, b, c, d, e, f
}

This is another victim of the strong typing however, since while these map to integers in C++, a=0, b=1. In java they are unmappable. (Does casting work?)

What I miss from Java.
Its somewhat more simplistic syntax and class system. Unfortunately, that wouldn’t work in C++, since there are hard defined uses for headers and source files. Without headers, libraries would be impossible (that is to say, hooking would be impossible, since headers provide the map required to access the compiled code). Without source files, compiling wouldn’t happen. (That is to say, source files are more required than header files).

Aside from that, the thing I probably miss the most from Java would have to be some of syntax sugar.