What is syntax?:

The syntax of a programming language is a set of rules specifying the way(s) in which operations may be specified to be carried out by a computer. They restrict the ways in which one may specify calculation, and make sure that there can be no ambiguities in the way to interpret a given snippet of code.

Operator syntax in C:

The first point to note in C is the order of operations. C has a number of operations, each with a certain priority. Higher levels of priority have all the operators on that level evaluated first - though a couple of levels, instead of having left-to-right priority within that level, have right-to-left priority. To change the order of operations, brackets override any other ordering, like they would inside a maths equation. C uses infix notation, which means that any binary (two operand) operator is placed between the two operands. For unary operators (one operand), the operator is placed before. Note that the exact way that binary operators look could be said to defy the above rule for operator[] and operator(), but this is moot at this point. Typically, the binary operators have a space between themselves and each operand, whereas unary operators are placed with no space. You must be careful using the unary operators since the same symbols can both be binary operators - it can be helpful to use brackets to make sure you don't accidentally get an undesirable result.

Function call syntax:

The correct way to call a function in C (explained more in functions) is function_name(arg1, arg2, arg3) if you are calling a function called "function_name" with arguments "arg1", "arg2", and "arg3".

main() function and writing code:

The center of ANY C program is the function main(). It is where the CPU first starts executing - anything that happens needs to be called/done by main(), or one of the functions it calls. main() can only be of a few forms. The exact syntax for functions also applies to main(), but nevertheless these following are the only allowed syntaxes (with the exception that one may use names other than the normal ones):

int main(){}

int main(void){}

int main(int argc, char **argv){}

int main(int argc, char **argv, char **envp){} //Note that this syntax is not specified in POSIX, but is used by all three main OSes.

Inbetween the braces ("{}"), any code should be placed. Two forward-slashes next to each other (and outside a string literal - explained later with the char data type) specify a line comment. A line comment tells the compiler to ignore the rest of the line. This allows a programmer to write little notes about their code. It is recommended that you comment your code as MUCH as possible. There are also multi-line comments. These start at any forward-slash-then-asterisk ("/*") and last until the next asterisk-then-forward-slash ("*/"). Comments can not be embedded, eg.

/*
  Comment
/*
  Comment 2
*/
  Not a comment! This will cause an error here!
*/

Not even within a single line comment:

// Comment /*
  Not a comment! Will cause an error!
*/

In C, it is important to note that whitespace is ignored - so the following snippets are all the same:

int main(void){}

int main(void)
{
}

int main (void) {
}

Each of these snippets incorporating elements of possible styles for writing C code. The main thing to note about whitespace is it only matters when it would be between two different things which could then make a single "symbol" (a symbol is a name representing a certain value - be it a function/function location or a variable). With proper syntax in all other ways, this only can cause problems when declaring variables/functions, or when casting. Just remember to place some whitespace between each specifier, qualifier, modifier, the type and the symbol name (specifiers, qualifiers and modifiers explained in that page). Programmers prefer to use a space, but these have the same meaning:

int x=1

int
x	=

1

The final thing to take note of for main() is the return value. You will learn all functions must have a return value - except main(), as it actually should be how your programs finishes (unless you use exit();), so errors won't be raised by it not returning - the system can jump out of the code for you. However, it is considered good practice to make use of a return value for main(). If the code finishes with no problems, main() should return 0. Otherwise, it should return some other value - normally 1. The syntax for a main() function that simply returns 0 is:

int main(void)
{
	return 0;
}

Now that we are done with that, a final note: you will have read about statements, and here is how they are used: each block of any set of operations to be performed MUST end with a semicolon. Normally what happens is you will have some declaration or initialization or function call or assignment, and then before you can do your next set of calculations to reach an end effect upon whatever you want to change next, you will use a semicolon to break up the blocks. This may sound confusing, but when to use one is quite intuitive if you think about it as going after any chunk of grouped operations.

Preprocessor directives

Preprocessor directives are further explained in their own page. Basically, before any compilation happens, based of a few system settings or compiler setting/command-line arguments, the preprocessor manipulates the source file. The main way this is done is with the #include directive. To use a preprocessor directive, the first character on the line must be a "#", immediately followed by the directive name, with NO whitespace between. A directive cannot span multiple lines unless a backslash ("\") is placed at the end of each line that is not the last to specify the directive continues on the next line. To use the #include is as follows:

#include <filename>

Or

#include "filename"

With this directive, the compiler copy-pastes the contents of the file into RAM in the place of the directive - or at least behaves like this is what happens. Note that the copy-paste happening in RAM means the original file doesn't have the directive replaced. The first example causes the compiler to search its "include path(s)" for the file. The include path(s) are literally just paths to search for files to include. The second one tells the compiler to ALSO search the system for the file. This is done using the regular system syntax. For example, you can just use the filename and no path if the file to include is in the same directory as the file including it with the second syntax. Note that included files should - but do not have to be - .h files, ie. C header files. Header files are explained on their own page. Remember that normal C source files should have the .c extension!