Arhk's C++ guide to the clueless ~ Absolute beginners

[Arhk]

I want to take some time out of my day to personally cover on some important concepts to help you with learning C++. I wont be bsing you with just redirections to "good books".... I mean nothings wrong with redirections but to be honest I'm sure if they wanted you to just point them to a book rather than having an actual programmer & hacker consult them. They would have very well averted the trip to MPGH and gone directly to the library or amazon.com (duh?)

I'm going to start where (when I get to it) every guide/tutorial on a programming language that gets eventual made into a binary executable format should begin.

/*Rather than coding languages that get compiled into an IL (intermediate language, pseudo codage) that is read and executed by an abstraction usually a VM (Virtual Machine) the process of VMs are real-time *abstractions lets define an abstraction as something that interfaces with the target (the machine, itself in this case) on the behalf of a program they run and interpret the IL executable into native code on the fly, after all computers don't magically understand things that aren't in the form of ones and zeros VB uses a VM called the CLR currently only Windows is in use of the CLR. Java using a VM component for running, Sun's JVM (Java Virtual Machine) can be found for really... Any Operating System and is more than often not is included in as apart of OS installation. Java is great If you like that sort of thing but C++ is what we're talking about here*/

I'll be spamming out alot of knowledge like that often so since I could find any [spoiler][/spoiler][hide][/hide] BBCode I've decided to put those blurts into C styled comments. They should require some Admin type tech savvy to keep up with, since tech savvy can't itself be taught I'll just hope you understand. I've done alot of reading on these things myself to become familiar with what alot of my Java coder friends call random facts I know some pretty semi-famous dudes in the PS Mapleworld (don't mock me) that actually didn't know what the JVM was or even what a VM is somehow they created successful server programs. I honestly believe HLL's like Java, VB encourage ignorance so I wont talk about them anymore so I'll detour back to what I was saying ('bout time....).

I'm going to start where (when I get to it) every guide/tutorial on a programming language that gets eventual made into a binary executable format should begin.

Yes if you guessed correct I indeed mean going over basic machine architecture.

Modern computers are based around the Von Neumann form of architectural thinking. That is, constant extraction and insertion of data. That is from the CPU to the Memory. Although there is an even deeper system of information transportation that goes on within the two. Does ALU mean anything to you? The CPU itself is a Grand Central of sorts... Only in the sense of it being a main terminal for the constant flow of data otherwise we'd be living in a totalitarian society. Things like being told where to sit (CPU storage of data, via registers), but there are obvious practical things like if you want to go file your taxes you have to take a certain train to get there for the task to be performed (basic ASM math functions like ADD, MUL that require certain registers EAX, EDX), there are some inadequacies in the analogy but computers are truly a bit more different an affair from Terminals.

[COLOR="GREEN]/*You'll eventually find it funny that the computer never truly strays from its binary nature (fairly stubborn it is). It's always just going through a strict set of binary responses no matter how much of a façade of dynamism it presents to its client. To put in proper ASM coder perspective the switch is either off or on, sometimes the system of switches is coordinated to set off other switches but nothing much other than that. I am indeed talking about the principle of voltage and absence of voltage, if you're a tech buff you know that the principle difference of a 1 and 0 in a computer is a matter of voltage. That is 1 usually representing voltage and 0 representing absence of voltage these numbers could have easily been used in switched roles (they themselves are only symbols). I do happen to know alot on the subject but moving on. */[/GREEN]

Disregarding the actual micro coded engineering that goes into these hardware units (we've gone this far VB programmers be very afraid), principally all machine tasks are done in binary, we're speaking real life here so I mean binary as in its actual output the actual system isn't simply 1's and 0's but that the presence and absence of voltage (usually 3-5V I think?) (using 1 to represent the presence and 0 as absence).
I'll only cover the basic memory interactions rather than getting into ASM things like flags and registers (how he leaves us hanging on). Think of this, the average computer works at 2Ghz usually a dual-core with today's modern technology. I accept the idea that 2Ghz @ dual-core is equal to a workforce of 2Ghz*1.8 rather than the obvious guess of *2 or any other number, though this level of multicore efficiency does likely fluctuate and would be differing across different microchips so no true definite answer can be given giving a static number for this is like me saying your processor will always be running @ 100% (frequency) or that it'll always have a work load of %5 thus at this low a level there are no constant numbers when it comes to performance we can only observe and average data of specific points (very much mere instances considering tasks are being performed by the nano-sec in a modern computer) in time for a some what reliable average. 2Ghz dual-core at 1.8, 90% efficiency (2*2 @ 90% or times 1.8) that is 3.6Ghz It does the work of a 3.6Ghz processor in the same time but not at the actual speed of 3.6Ghz these are two processors working at 2Ghz side-by-side. Lets start like this kilo is a thousand mega is a million giga is a billion . 2Ghz is the amount of Cycles performed within a second. a hertz is indeed a measurement of oscillations (Sound waves are oscillating that is the one wave after another thing, that is the relation) per second the computer stays true to the nature of the true meaning. 2Giga hertz is 2billion cycles per second (dual-core). An oscillating clock inside the processor initiates one cycle after another well...... Like clock work. With every oscillation switches are either flipped or not flipped. Anything related to the concept of 0 at this level should be thought of as null or void that is, things aren't initiated or made to represent a 0 value but is simply the absence of value, that is null, or... void (this is very important in C/C++ and ASM keep this concept right in the forefront of your mind). Some switches, in-turn turn switch other switches, with this the processor can address places in memory and in-turn that place in memory will cause another response in switches. And in this process the CPU essentially accepts information in the format of 1's and 0's. Diverting from the heavy stuff.....

The idea behind computers is that data can only be manipulated and addressed in the smallest by one byte packages.

/* I want to change the bits 10000111 into 11111111 I perform something referred to as bit manipulation or bit masking.
the operation that would be useful for this is

10000111 | 11111111

and even if I want to change one bit.

10000111 | 00001000

the "|" symbol is the bitwise manipulator called OR, I wont be showing you truth tables or bit manipulation yet so Google around if your interested in getting ahead on this topic

if you want to perform an operation with the binary value seven you can't simply address only 3bits 111. You have to address 00000111 a whole byte package of data. Packages must be composed in whole bytes, of course if your binary number doesn't fit into byte packages you zero the rest of the space in the byte.
the value decimal 1100
binary input
100 01001100
_________________
|BYTE----|BYTE----|
|?????100|01001100|
|_______ |________|

this is assuming your computer uses big endian for storing data rather than little endian (I would be most surprised honestly, but bi-edianess can be expected somewhat of today's architecture). 1011 in little endian is 1101 this is the same difference in languages that are written from left to right and right to left....
Memory can only be addressed by byte packages rather than the assumption you might have come with. That is that the computer could address data by bits , a computer can/will only look at 8bits at a time that is a byte that is why you wont often here people talk about bits instead of saying an 8bit package of data we say byte. */

To make this quick 1byte is 8bits a bit indeed relating directly to the switch analogy 8bits (that is a package of eight ones or zeros) make a byte. Memory is divided into blocks by which to be addressed by. These blocks can be any size, but must be composed of smaller 8bit byte blocks. These blocks are data made by the computer to hold information. These blocks can also be initiated by the programmer when he creates a variable in C++.

Here's the doozy we actually need to cut off here to teach you some basic C++ now. But it's my curfew so.... I'll be back tmmrrwz. Ahhh maybe a little more...

How about we finally say Hello World!.... To C++ types (He's cruel isn't he..?).

In our world of programming there are several types of data. C being a strictly procedural language, C++ has inherited the procedural ideals of C (the C programmers rejoice) with some OOP (Object Oriented programming) (C coders: ehhh...). In OOP languages like VB the e***asis is on the object with this type of programming focus is on the data and orienting the computer to fit the needs of that data. In C the e***asis is on procedure, that is the instruction for the data, how the data should be handled and carried out that is the user fitting the needs of the computer, which promotes faster programs. The difference is in OOP like VB (forgive me) you can point and click to make windows, but in wxDev-cpp if you want to make a window you take this code template and make sense of it

#include <windows.h>

/*  Declare Windows procedure  */
LRESULT CALLBACK WindowProcedure (HWND, UINT, WPARAM, LPARAM);

/*  Make the class name into a global variable  */
char szClassName[ ] = "WindowsApp";

int WINAPI WinMain (HINSTANCE hThisInstance,
                    HINSTANCE hPrevInstance,
                    LPSTR lpszArgument,
                    int nFunsterStil)

{
    HWND hwnd;               /* This is the handle for our window */
    MSG messages;            /* Here messages to the application are saved */
    WNDCLASSEX wincl;        /* Data structure for the windowclass */

    /* The Window structure */
    wincl.hInstance = hThisInstance;
    wincl.lpszClassName = szClassName;
    wincl.lpfnWndProc = WindowProcedure;      /* This function is called by windows */
    wincl.style = CS_DBLCLKS;                 /* Catch double-clicks */
    wincl.cbSize = sizeof (WNDCLASSEX);

    /* Use default icon and mouse-pointer */
    wincl.hIcon = LoadIcon (NULL, IDI_APPLICATION);
    wincl.hIconSm = LoadIcon (NULL, IDI_APPLICATION);
    wincl.hCursor = LoadCursor (NULL, IDC_ARROW);
    wincl.lpszMenuName = NULL;                 /* No menu */
    wincl.cbClsExtra = 0;                      /* No extra bytes after the window class */
    wincl.cbWndExtra = 0;                      /* structure or the window instance */
    /* Use Windows's default color as the background of the window */
    wincl.hbrBackground = (HBRUSH) COLOR_BACKGROUND;

    /* Register the window class, and if it fails quit the program */
    if (!RegisterClassEx (&wincl))
        return 0;

    /* The class is registered, let's create the program*/
    hwnd = CreateWindowEx (
           0,                   /* Extended possibilites for variation */
           szClassName,         /* Classname */
           "Windows App",       /* Title Text */
           WS_OVERLAPPEDWINDOW, /* default window */
           CW_USEDEFAULT,       /* Windows decides the position */
           CW_USEDEFAULT,       /* where the window ends up on the screen */
           544,                 /* The programs width */
           375,                 /* and height in pixels */
           HWND_DESKTOP,        /* The window is a child-window to desktop */
           NULL,                /* No menu */
           hThisInstance,       /* Program Instance handler */
           NULL                 /* No Window Creation data */
           );

    /* Make the window visible on the screen */
    ShowWindow (hwnd, nFunsterStil);

    /* Run the message loop. It will run until GetMessage() returns 0 */
    while (GetMessage (&messages, NULL, 0, 0))
    {
        /* Translate virtual-key messages into character messages */
        TranslateMessage(&messages);
        /* Send message to WindowProcedure */
        DispatchMessage(&messages);
    }

    /* The program return-value is 0 - The value that PostQuitMessage() gave */
    return messages.wParam;
}


/*  This function is called by the Windows function DispatchMessage()  */

LRESULT CALLBACK WindowProcedure (HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
{
    switch (message)                  /* handle the messages */
    {
        case WM_DESTROY:
            PostQuitMessage (0);       /* send a WM_QUIT to the message queue */
            break;
        default:                      /* for messages that we don't deal with */
            return DefWindowProc (hwnd, message, wParam, lParam);
    }

    return 0;
}

with this template a world of powerful debugging and managing methods are open to you while in VB, there is considerable lack of GUI control (Graphical user interface, in this case windows). OOP is making the machine fit our needs in order to make projects simpler and faster (to complete), while procedural programming is really conforming our way of thinking to the machine allowing for faster running programs that can really do more, and have more control over things. With C++ I can control where in memory data is moved, but in ASM I can control everything to know there is a process to this move, first a storage spot in the CPU (a register) must be decided and the address of the memory location must be sent to the register and then this register data is transferred to a memory location. There is an even deeper process to that, so if you find any inadequacies good, it was meant to be that way since I was showing the limitations by describing only the user submitted side of things.

This is where most tutorials begin with introducing higher level concept like data types (some jump the gun completely with introducing the Hello World! sequence). Data types are declared in a C/C++ with statements like

// These are comments they have no effect on the compilation or
//the compiled executable/product, // initiates a (single) line to be a comment opening with /* and closing with */ allows
//anything in between the opening and closing symbols to be made as comments in the source code those are C styled comments (regardless of how many lines it extends*.
//line 1
//line 2
/* line 1
line2 */
int jerry;
//you've intiated a value in memory of size int, and its 
//memory location has 
//been associated with the name "jerry"
jerry = 5;
// the memory location that is associated with the name "jerry" has been assigned the value 5

This is where most tutorials begin with introducing higher level concept like data types (some jump the gun completely with introducing the Hello World! sequence).
jerry in a literal sense is a number that describes its location in memory, but aslong as we address it by the name jerry, C++ will know we want it to perform the operations on the data at the location jerry (rather than the location number the variable jerry holds itself) which the compiler keeps track of its literal value that tells what specific byte block in memory jerry is (the actual byte location in your computer's memory). The compiler also keeps track of how many byte blocks jerry extends by what type we declared jerry as. That's why jerry and any other variable only needs to hold its starting point literal value rather than both its starting and ending point. All the compiler needs in-order to understand where jerry is and how many blocks (bytes) jerry takes up is for you to say <type> jerry. A variable takes up a certain amount of space according to its type an int type variable is most often 32bits in size (when I said 16bits to why06 it was because I've been reading 30 year old C books). 32bits divide by 8 is 4 blocks, jerry takes up 4blocks, that is 4bytes. The compiler understands that according to its type jerry is 4bytes and should be made in memory to extend 4bytes (32bits, thirty-two 1's and 0's). The starting point of that 4bytes is stored in jerry and the compiler recognizes that when jerry is called we want to edit data at the 4byte location starting at the value jerry is holding. These 4bytes are jerry's block, that is jerry's block in memory extends 4bytes.

How did I come to that conclusion you say ESP(N)? Well C/C++ has a group of (old guys) old pros who come and meet up to agree on standards for C/C++ The standards for the size of variable types like jerry (that is int)
int guarantees to be atleast as big as a short (16bits) and that's the only certainty.
A short is guaranteed to be atleast 16bits.
A long is guaranteed to be atleast as big as an int.

The uncertainty is a bit riddling. But know in most cases an int is indeed equal to 32bits, and a short is 16bits, a long is most often a "full" 32bits.

How much can I store in 4 bytes....?
4bytes = 32bits
you can store 32binary integers in jerry's 4byte block.
11111111 11111111 11111111 11111111
these are 4blocks I'll talk as if all data were big endian so that means the starting block is to the right (odd?) if you do find this odd your looking at these blocks as a set of text (LTR) rather than their true meaning as a number system that should be thought of as a least significant to the right and most significant to the left that is three hundred forty-two 342 rather than 243 the hundreds column is the most significant so we place that up front to the left. To resolve any possible directional conflict it might bring, the boxes will also be talked about going from Right to Left that is least significant to most.
_________________________
|--------|---------|---------|
|--------|---------|---------|
|_______|________| _______|
3----2----1

16bits, 32bits.... What does that mean.....? Binary takes on many forms within your computer that is the physical manifestation of a binary system by presence and absence of voltage. And in terms of data Binary is most certainly a number system a bit is a binary integer, bits are binary integers. Bits, Binary integers are not these completely abstract foreign things. They are numbers having values just like how we think of decimal numbers 10 two 11 three. The key thing to realize once you're a programmer especially a hacker is that 1,2,3,4,5,6,7,8,9, and all the letters in the alphabet are all just symbols they only have meaning according to their context. 0 , zero is indeed an advanced concept within itself which is why the concept wasn't thought up until much after the advent of one (the symbol for zero could also be substituted but regular number systems don't usually get this weird).
There's no subscript BBCode here so I'll be GIMPing up example images for teaching you how to count in different number systems.



Hex that is hexadecimal will be the number system you'll be using most often as you mature as a programmer. Observe the chart, I would memorize that hexadecimal uses the characters 1-F to represent the decimal 1-15. Remember that 10 has different meanings in different number systems in Hexadecimal it's sixteen in binary it's two in decimal it's ten.

I'll now show you the key to decoding number systems. This is a slow but easy way to figure them out. First I'll explain in words then I'll explain in more GIMPing. Number systems have bases, different bases, binary is base 2, decimal is base 10, hexadecimal is base 16. If you're a wiz kid you've realized that the naming scheme of the system match with their bases (as they should) The prefix "Bi" means two, Decimal means ten (somehow) hex actually means six even though it's used to refer to hexadecimal (six+ten).
As you'll realize all of the right most columns in any number system is the one's column. All number systems do have rhyme and maybe some reason, we can find the value of any base number system integer by knowing the value of all of its one's column symbols we know the value of 1-9 and even hex's extended A-F. And knowing its base (more rhyme and reason). A base is also called the radix I prefer the term radix it's more coder sounding.

We will now find out how large an integer decimal value can fit in 8, 16, and 32 bits. If not already known (sad) and integer is a whole number (not 4.2 or 4 1/2) that can be either negative or positive.



The rows are a bit misaligned but you can figure it out. Put your radix to the power of the number of the place counting from 0. Any number to the zeroth power is one so our radix 2 to the zeroth power results in one that is the value of that column it is the one's column because the resulting value of any radix to the zeroth power is one. We know in binary the 1 symbol represents the value one so we have one, ones, the next column which is demarked with the placement number 1 any radix to the 1st power is indeed itself. So this column is the two's column (in decimal this would be the tens columns) we have one twos. Next is the place demarked by 2 the third column, this in decimal is the hundreds column but what is it in binary...? 2^2 two to the second power is four this is the four's column we have one fours. And so on and so forth. This system can figure out any logical number system .



Our radix is ten so ten to the zeroth power is one, the symbol 3 in decimal means three so we have three ones. Any number to the first power is itself, the symbol 4 in decimal means four so we have four tens. Ten to the second power is one hundred we have two hundreds.



Our radix is sixteen, sixteen to the zeroth power is one like with any number to the zeroth power. Sixteen to the first power is itself, this is the value of this column, sixteen. The F symbol in hexadecimal means the decimal 15 that is fifteen. We have fifteen in the sixteen's column, that is fifteen sixteens. Fifteen sixteens is fifteen times sixteen. In decimal that is 15 * 16, two hundred forty. So together we have seven ones and fifteen sixteens (7*1 + 15* 16) F7 that is 247 in decimal. If you want to figure out decoding 16bit and 32bit values convert a binary value 32bits long into the different number systems, this will be pretty slow but maybe doing something on your own will help you understand better what I've said.

Head is hurting me so I'm gonna take a breather (my anorexia)....

All data in a computer can be seen as represented numerically. If we want to store the number 7 as a value for something we/or the computer puts in the appropriate binary pattern. In computing you should know all things (bits) get their meaning from context. And understanding that the binary pattern 01000001 (note this number is 8bits) can be telling the computer to assign the value 65 to a byte sized storage space in memory, or to refer to the character 'A', all depends on context and this context is derived from the variable's type (like int), and how you the programmer make use of that variable.

In all honesty bits in relation to IT are truly more patterns than numbers. We interpret them to be numbers so that they're recognizable to us but, in essence they are patterns because these patterns of 1's and 0's can have very versatile meanings according to context.

In the context of a GPU (Graphics Processing Unit, in the graphics component of your computer) those patterns of 1's and
0's can represent vectors(mathematical data for plotting colors) or colors(colours). Specialized hardware like the GPU take patterns in the form of bits (in atleast the size of byte blocks) from the CPU, and do specialized tasks like making it possible for you to have a screen to look at (01000001 to a GPU could be the value red for a pixel, on a very old GPU). Or for an even broader view of this specialized adaption of these binary patterns, things like finger scanners and USB gadgets of the such specialize these binary patterns of 1's and 0's to make something useful for a specialized task. For specialized hardware applications it's your job what these patterns then mean to said hardware, <type> (your context finder) name, vector jerry (store mathematical data for plotting of pixels in memory location jerry).
pixel jerry (store the color value in memory location jerry).
As with int jerry the compiler knows the extent of the jerrys by their type (since all types have a standard sized, int is 32bits) and the beginning of their memory block because his name has been associated with a literal number for its location in memory (its memory address).

It's important that you understand computers address data by byte packages, there is no rule to how many bytes at a time can be addressed but they must be composed to fit/extend into blocks of 8bits. This relates to things called Registers, registers in 32bit CPU's at the largest are 32bits the largest value to fit in a 32bit package is 4294967295, since registers are used to address memory by the byte (block) there are 4294967296 addressable blocks since 0 is a valid place to address (not sure if you want to though). 4294967295bytes = 4gigabytes, so with that said the limit of RAM (memory) in x86 (32bit) architecture is 4Gigabytes. The envolope could be pushed by a method of offset, using a pair of 32bits registers to address memory, but offsets have become an unused method.
~
A work in progress

[why06]

Any particular reason you reposted the same thread. =/

[Invidus]

double post??O.o

[Void]

He added a little more to it.

[Arhk]

I fixed it (lots more detail) basically and added to the number system thing.
~
you could take note of the fact this is significantly longer than the previous.

[Void]

Hmm, just a suggestion but. I think, when making a new thread, or when deciding to add to your tutorial. Don't rewrite the whole thing with the new stuff. Then the people who read your old ones will have to find what you added, basically re reading what you wrote before.

That's just my opinion. >_>

[Arhk]

Revisions are important nonetheless. It's not like you can ever expect anyone to look back on something and not find things they'd like to improve....
~
I'll leave this part of the tut at this rev, I'll make a part 2 for the next topics.
I'll talk a little bit more about how the compiler manages memory and the stack then move into a classical "Hello World" sequence... Sumarizing what functions are, how they work, their types (return, input). And probably pushing on into basic memory management and some OOP with structs unions and classes. Idk I'll probably add a lot more topics in between things I mentioned.

[why06]

Revisions are important nonetheless. It's not like you can ever expect anyone to look back on something and not find things they'd like to improve....

Agreed, but either way Im just going to replace your old one with this one, because Im too lazy to change links in the tutorial thread. I'll wait till you finish editing however. Since I don't want to do it twice.

[Arhk]

K thanks
~