What's New!

Chat with
Hackers

How to Defend
Your Computer 

The Guides
to (mostly) 
Harmless Hacking

Happy Hacker 
Digests (old stuff) 

Hacker Links 

Hacker
Wargames 

Meet the 
Happy Hacksters 

Help for 
Beginners 

Hacker 
Bookstore 

Humor 

It Sucks 
to Be Me!

How to Commit
Computer Crime (not)! 

What Is a 
Hacker, Anyhow? 

Have a 
Great Life! 

News from the 
Hacker War Front

More How to Program in C

### 5.0 Parts and pieces of a C program
----------------------------------------------------------------------

As we have seen in the above example, the process to create an executable program from a source code can abbreviated as:

    source code --> compiler --> executable program

Imagine that you want to write a really big program, say, a 3D-CAD-engine with midi interface, drumkit and real time video. This will really need a large number of lines of code to write down.  What? You want to write all these lines into one very long text file? Oh, no, that is not a good idea!

    It will be easier to write, debug, and build into a working program if you split it into a couple of files.  To make things easier, you would name each file after its contents.  For example, if you want to use the number Pi (3.1415926...), you could declare it as a constant and put it into an extra file.

    And now???

    Looking at the above example, you will get a problem: each source file fed into the compiler seems to produce one complete executable program!

    Lost?

    No! You can instruct the compiler to produce output of an  "intermediate state", if you want half translated source code.  These resulting files are called "object files" (don't ask me why...).

    After translating all single files into object files, in a last step you have to "link" them into an executable program.

    LINK?

    Yes! Linking is a process, where all "untranslated" things, left in the files, are translated and make to fit together.  Now, you have your program!

These were the "outer pieces" of a program. But the program is divided internally, too.

    These parts are called functions or procedures. There is an academically difference between them, but I take it not that seriously. Later I will show you why.

    For now, let's speak about procedures, and keep in mind, that there is another name ("functions"), which nearly the same meaning.

    Ok, back to the main theme... ;-)

    A procedure is a part of code, which do a certain thing for us, for example, it makes a sound, adds two numbers or blacken the screen (a simple screensaver). Each procedure has its own name.

    But one procedure is special. It is the start, where execution of the program begins. This function is called "main."  All other functions must have other names.

    Look at the above example program. It consist of one procedure only, the "main"-procedure. 

### 6.0 Your Programming Environment
----------------------------------------------------------------------

    Let's have a closer look to what is called a "programming environment". But, what is it?

    A programming environment consists of all the things you need to write programs.  Often you can buy things called "integrated programming environment", mostly programs which should do "all" for you. Mostly they aren't worth the money...

    Why?

    Simply: You can get similar things for free, with all source codes of all used programs including the compiler itself (mostly a best protected secret of companies like MicroSh*t -- so this is a "hack" itself: you gain knowledge of a secret by simply downloading a tar ball ;-)

    And, more important, you can fit things together in your way, as _you_like it. No colored "click here, crash there" with the mouse. If something fails, YOU have the control. Search the error, learn from it, fix it! You don't need people who tell you, what's good for you, do it your way!

    Back to the / ...;-)

    A programming environment for the language "C" consists mainly of a couple of programs and files:

-- an ASCII text editor (don't a word processor!)
-- a C compiler
-- libraries
-- header files

    Until now, we know the ASCII editor, which we have used to enter our first example program. We also know our C compiler and of what kind it is (K&R or ANSI). But what are "libraries????

    Great halls of books? Yes and NO. In this case: NO. A library is a collection of often used procedures.  These procedures has been pre-translated by the compiler.  So, if you want to use a procedure which has been written by someone else and included into a library for you, the only thing you have to do is to instruct the compiler to link against this library.

    Linking is the process where half translated parts of a program, mainly different source codes were made fit together by translating them fully (see above).

    The only thing you need to use the libraries are header files.

    Imagine the following situation: You are writing a program. You want to use a library function, say "printf" of the HelloHacker program.  But instead of typing "printf" you hacked "rpintf" into your keyboard.

    You feed the source code into the compiler. Now the compiler comes to "rpintf" and wants to know whether this is a function defined later in the source code or in a library (in which case it would pretranslate it and won't produce an error message) or whether this function is "unknown", which means: "I don't know anything about this function. Hey, hacker! This one I don't know! So: Define one, or I will not work for you!"

    Most compilers aren't that friendly and won't say anything nearly that nice. It will say something like:

    undefined reference to `rpintf'

    This is the reason why header files are used. Header files contain (not only) so called "prototypes". Prototypes are "announcements" for later defined procedures of libraries.

    So, before you can define or use a function, you have to write down a prototype of it. It is like saying to the compiler  "Hey, compiler, if you will find this one later in the source code, don't grumble! Here is what it should look like!"

    Additionally some important constants are defined in header files, for example the often used constant PI. It is more easy to type "PI" than to remember 3.1415926... every time and write it down correctly. And other things are defined there. Becoming curious? OK, type

   more /usr/include/stdlib.h

    This is only one of the standard header files. Much stuff, isn't it? Maybe you will find the file in another place on your computer, maybe /usr/local/include or something like this. But in most cases it is in /usr/include...

Oh, before I forget! One I have left out in the above list of things found in a programming environment: The debugger. A debugger is a program which helps in finding bugs in a program. But because debuggers are not part of any definition of C, each debugger works in a different way. It is beyond the scope of this tutorial to show how to use a debugger. If you want more, try

    man db

or

    man gdb

at your account. Manpagers are often the best source of informations, you can get.

More how to program in C --->


Carolyn's most
popular book,
in 4th edition now!
For advanced
hacker studies,
read Carolyn's
Google Groups
Subscribe to Happy Hacker
Email:
Visit this group

 

Return to the index of Guides to (mostly) Harmless Hacking!

 © 2013 Happy Hacker All rights reserved.