al_init() needs to be called to call most allegro functions. If you want to skip the check (but why would you? checking for errors is a good thing!), just remove the `if(! )` and the `{}` block below it.

The only thing you do not really need is the al_rest call. This will make everything pause for 10 seconds.

You may also want to look at other al_init_* functions because they are needed for sound, gamepad,ttf text drawing, and more.

In programming, everything is mandatory. The biggest "optional" stuff you can possibly get is omitting explicitly setting up values that already set by default if they satisfy you. However, you shouldn't rely on that things will work on their own, so explicitly stating virtually everything is not only a good practice, but also a failsafe from unexpected behavior in underlying system.

------

Also, since you're only learning, I suggest you to use C rather than C++. It's (vastly) easier to learn and to work with, which is a big deal for you right now. (Not that simplicity is a bad thing: C++ is overcomplicated lightyears over the top, and all of the complexity hardly gives any benefits while certainly making your life harder.) Examples are written in C, too, which is another reason for you to use it.

C is, for the most part (that has changed a bit since c++11, and c99, there are more differences between the two than there were) a subset of C++. C doesn't have classes, exceptions, or templates. C is procedural programming at its finest.

C is not a subset of C++, because C++ can't compile C code. Technically, you could force it to do so using specifically coded programs, but that's not valid argument.

Allegro runs on C.

As opposed to C++, C lacks of syntax sugar. That's about it. They do everything similarry and capabilities are exactly the same, but C does it straightforward while C++ uses complicated and (for the most part) confusing patterns.

http://www.cprogramming.com/tutorial/c/lesson1.html

Just make sure you don't treat programming as magical stuff that you "copy from a book and then it works". All there is to program execution is juggling bytes, numbers. Everything is the number, one way or another.

Having done a lot of OOP, I'd feel closer to the opposite. C++ uses straightforward patterns (except for the whole header/source separation, but C has that problem too), but C makes you jump through unnecessary hoops.

It really just depends on what you're comfortable with and what you want to do, though. I'd probably recommend C++ over C if only for the fact that it's more similar to the other currently popular languages than C is.

Everyone knows this one:

typedef int foo;
struct foo { int x; };

I was surprised by this one: (technically it compiles)

printf("%d\n", sizeof('a'));

Also: Works in C, but not as C++^[1]. Or even this works in C, but not in C++^[2].

Is C++ backwards compatible with C?

For all in-tents and purposes, I'd agree that C is a subset of C++. If your C program isn't compilable as C++, it's probably poorly written. The second example I posted may have it's uses, but it's a fairly trivial fix, plus I think most people write prototypes anyway.

--------------------------------------------
Appendix: Valid C, but invalid C++:

//[1]
void foo() { printf("ok\n"); }

int main() {
   foo(1, 2, 3, 4, 5);
   return 0;
}

//[2]
int main() {
   foo();
   return 0;
}

void foo() { printf("ok\n"); }

I do normally cast pointer types, in my data structures handling. You wouldn't write it's own stack implementation for every possible data type, would you? Provided typecasting and pointer math hardly (if any) takes more processing than direct approach. And silly C++ with it's silly restrictions will complain about casting issues so hard that the code won't work. Way to go simplicity, Jeff.

What makes any surprise to you? 'X' would be a char constant, what's confusing with getting size of a char constant?

For some reason, 'X' is an int constant in C.

Well, it did treated it as an unsigned int. This is not entirely what I expected, but it's still perfectly reasonable: unless you trying to save space, you choose an int, because it would perfectly fit the register, naturally keeps byte alignment and the bus will probably fetch it faster from RAM. Since this letter would end up directly in registers, there's no need to save space whatsoever, so it's 4 bytes. Also, it allows using unicode characters rather than ASCII characters.

C doesn't define boolean type. The if block only recognizes zero and non-zero value. You could use char for bool as well as int, you could as well use bithacks to place 8 booleans into a single char. Myself, I hardly ever use booleans. Instead, I use goto jumps, which is the basic reason for most people to even use booleans - to avoid gotos because "they're bad" and "you can't use them". ------ But when I do, it's an int bitfield.