sudo apt-get install libfontconfig1:i386 libx11-6:i386 libxrender1:i386 \ libxext6:i386 libgl1-mesa-glx:i386 libglu1-mesa:i386 libglib2.0-0:i386 libsm6:i386 cd /tmp && wget http://dl.google.com/dl/earth/client/current/google-earth-stable_current_i386.deb sudo dpkg -i google-earth-stable_current_i386.deb sudo apt-get install -f
sudo apt-get install cmake build-essential opencc mercurial ibus
hg clone http://code.google.com/p/libgooglepinyin.ibus-wrapper/ ibus-googlepinyin
cd ibus-googlepinyin
mkdir build; cd build
cmake .. -DCMAKE_INSTALL_PREFIX=/usr
make
sudo make install
pkill -f ibus-daemon ; ibus-daemon -d -x
ibus-setup
sudo apt-get install python-software-properties
sudo add-apt-repository ppa:webupd8team/java
sudo apt-get update
sudo apt-get install oracle-java7-installer
const instead of finalconst objectsconst pointersmain() functionchar, int, float, double, signed,unsigned, long, short and void. The allowable combinations are listed below, but their meanings depend on the compiler and platform in use, unlike Java.unsigned charsigned charunsigned charcharunsigned shortunsigned char, typically (and always at least) 16 bitsshortunsigned shortunsignedunsigned short, and wider than the char types — 16- or 32-bit widths are common.intunsignedunsigned longunsigned, typically (and always at least) 32 bitslongunsigned longunsigned long longunsigned long, typically (and always at least) 64 bitslong longunsigned long longfloatdoublelong doublevoidvoid. Unlike Java, a function with no parameters has void in its parameter list.int (for example) means the same as a Java int. Furthermore, C's signed types do not have to use two's-complement notation, and Java does not have unsigned types.if, while and for statements, and the operands of the logical operators (!, && and ||), are integer expressions with a boolean interpretation: zero means false, non-zero means true. The relational operators (==, !=, <=, >=, < and >) and logical operators return 0 for false and 1 for true.bool (which is really just a very small integer type) and symbolic values true and false(i.e. just 1 and 0), but the other integer types work just as well as before./* a multiline comment */ // a single-line commentPrior to C99, C does not permit the single-line form.
/* enabled code */ #if 0 /* disabled code */ #endif /* enabled code */
static./* file db.h */ #ifndef db_included #define db_included /* pointer to incomplete structure type */ typedef struct db_handle *dbref; /* a constructor */ dbref db_open(const char *addr); /* methods */ int db_get(dbref, const char *key); /* etc */ /* a destructor */ void db_close(dbref); #endifNote that C does not have any notion of ‘constructor’ or ‘method’. They are just ordinary functions alike.
/* file db.c */ /* Include the header, so we ensure that our definitions and declarations are consistent. */ #include "db.h" struct db_handle { /* . . . */ }; /* UseAs a result, the internal structure of your database handle can change over time without affecting its users, as they can't see inside it. The functions declared withstaticfor internal state and private functions... */ static void normalize_key(char *to, const char *from) { /* . . . */ } dbref db_open(const char *addr) { /* Allocate astruct db_handle, and initialize it... */ } int db_get(dbref db, const char *key) { /* Use info indbto access an entry... */ } void db_close(dbref) { /* Release memory... */ }
static are not visible outside db.c, so they won't clash with identically named functions in other parts of the program. However, the compiler will not force a user of your library to initialize a dbrefcorrectly with db_open, or to release it after use correctly with db_close. He is expected to have enough self-discipline to do that himself.class construct), but you can declare C structures using the struct construct. A C structure is like a Java class that only contains public data members — there must be no functions, and all parts are visible to any code that knows the declaration. For example:struct point {
int x, y;
};
This declares a type called struct point (NB: ‘struct’ is part of the name; point is known as the structure type's tag).. operator, as class members can be in Java:struct point location; location.x = 10; location.y = 13;A structure object may be initialised where it is defined:
struct point location = { 10, 13 };
/* okay; initialisation (part of definition) */
location = { 4, 5 };
/* illegal; assignment (not part of definition) */
In C99, you can create anonymous structure objects to perform compound assignement:location = (struct point) { 4, 5 }; /* legal in C99 */
In C99, a structure initialisation can specify which members are being set:struct point location = { .y = 13, .x = 10 }; /* legal in C99 */
Unlike Java, where class variables are references to objects, C structure variables are the objects themselves. Assigning one to another causes copying of the members:struct point a = { 1, 2 };
struct point b;
b = a; /* copies a.x to b.x, and a.y to b.y */
b.x = 10; /* does not affect a.x */
public static final int RED = 0; public static final int REDAMBER = 1; public static final int GREEN = 2; public static final int AMBER = 3;(Java also has a class
java.util.Enumeration, which serves a different, unrelated purpose.) public enum LightState { RED, REDAMBER, GREEN, AMBER }
These are distinct instances of a class type, and don't correspond to integer values (apart from their order).enum light { RED, REDAMBER, GREEN, AMBER };
This defines a new type enum light, and defines the symbols RED for 0, REDAMBER for 1, GREEN for 2, and AMBER for 3.0, and each subsequent symbol is assigned the next integer. However, a symbol can be assigned a particular value:enum light { RED = 3, REDAMBER, GREEN = 1, AMBER };
This also implies that REDAMBER is 4, and that AMBER is 2.enum { RED, REDAMBER, GREEN, AMBER };
The symbols can be used in any expression, and may be assigned to any integral type, not just the enum type. For this reason, the tag is rarely used.enums are no more sophisticated than that. In contrast to Java, the symbols are not objects, and cannot take parameters.union number {
char c;
int i;
float f;
double d;
};
This declares a type called union number (NB: ‘union’ is part of the name; number is known as the union's tag).. operator, just as structure members are accessed:union number n; int j; n.i = 10; j = n.i;Only the member to which a value was last assigned contains valid information to be read. There is no way to determine that member implicitly, so the programmer must take steps to identify it, for example, by using a separate variable to indicate the type:
union number n;
enum { CHAR, INT, FLOAT, DOUBLE } nt;
n.i = 10;
nt = INT;
switch (nt) {
case CHAR:
/* access n.c */
break;
case INT:
/* access n.i */
break;
case FLOAT:
/* access n.f */
break;
case DOUBLE:
/* access n.d */
break;
}
Java does not have unions, although it is possible for a reference to refer to any class derived from its own class. A reference of type java.lang.Object can refer to any class of object, since all classes are originally derived fromjava.lang.Object.importdirective. For example, the method java.lang.Integer.toString() is distinct from java.lang.Long.toString(). Java packages similarly allow distinct classes and interfaces to share the same name. For example, the name Object could refer to either java.lang.Object or org.omg.CORBA.Object.WSAprefixes most of the WinSock functions.void myfunc(int a)
{
/* ... */
}
void myfunc(float b) /* error: myfunc already defined */
{
/* ... */
}
typedef. For example:typedef int int32_t;This allows
int32_t to be used anywhere in place of int. Such aliases are often used to hide implementation- or platform-specific details, or to allow the choice of a widely-used type to be changed easily.typedefs are also useful for expressing complex compound types. For example, a prototype for the standard-library function signal has the following, rather cryptic form (in ISO C):void (*signal(int signum, void (*handler)(int)))(int);Erm, what? It becomes a little clearer when POSIX (an Operating System standard which incorporates the C standard) declares it:
typedef void (*sighandler_t)(int); sighandler_t signal(int signum, sighandler_t handler);Now we can see that the function's second parameter has the same type as its return value, and that that type is, in fact, a pointer-to-function type.
typedef is syntactically similar to a variable declaration, with the new type name appearing in the place of the variable name.{’ and ‘}’)) is replaced by a semicolon (syntactically similar to anative method, or an interface method, in Java). If the compiler finds a function invocation before any declaration, it will try to infer a declaration from the invocation, and this may not match the true definition. A proper declaration can be inferred from a function definition, should that be encountered first./* a declaration; parameter names may be omitted */
int power(int base, int exponent);
/* From here until the end of the file, we can make calls to power(),
even though the definition hasn't been encountered. */
/* a definition; parameter names do not need to match declaration */
int power(int b, int e)
{
int r = 1;
while (e-- > 0)
r *= b;
return r;
}
int globval = 34; /* initialized */ int another; /* initialized with 0 */…while a declaration should not have an initialiser, and should be preceded by
extern:extern int globval; extern int another;(
extern can also appear before a function declaration, but it is optional.){
int x; /* a definition */
x = 10; /* a statement */
int y; /* illegal; follows a statement */
}
Furthermore, an iteration variable in a for loop cannot be declared within the initialisation of the statement:{
for (int x = 0; x < 10; x++) { /* illegal */
/* ... */
}
}
This restriction does not apply in C99.{
/* a local type */
typedef int MyInteger;
/* a local variable */
MyInteger x;
/* global variable */
extern int y;
/* function (CODE(extern) is implicit) */
int power(int base, int exponent);
/* statements... */
}
Unlike Java, a local variable in an inner block may hide one in an outer block by having the same name:{
int x;
{
int x; /* hides the other */
}
/* first one visible again */
}
(). In C, such a function should be expressed with (void) in its declaration and definition. However, it is still invoked with ():/* prototype/declaration */ int myfunc(void); /* definition */ int myfunc(void) { /* ... */ } /* invocation */ myfunc();The form
() is permitted in declarations, but it means ‘unspecified arguments’ rather than ‘no arguments’. This tells the compiler to abandon type-checking of arguments where that function is invoked. It comes from an obsolete pre-standard version of C, and is not recommended.extern int errno;
void func(void)
{
double pow(double, double);
double x = 3.0, y = 12.7, r;
int e;
r = pow(x, y);
e = errno;
/* ... */
}
Like Java, C comes with a standard library of general-purpose support routines, an implementation of which is supplied with your compiler. Its source code is not usually required, since it has already been compiled into object files for your system, and these will be used automatically when linking./* This declares the typeIt would be tedious to repeat such declarations in each source file that requires them, particularly if they need to be modified as the program develops. Instead, these could be placed in a separate file (usually with a .h extension), and inserted automatically by the preprocessor when it encounters anstruct point. */ struct point { int x, y; }; /* This declares the global variableerrno. */ extern int errno; /* this declares the functiongetchar. */ int getchar(void);
#include directive embedded in the source code, for example:#include "mydecls.h"These header files are also preprocessed, and so may contain further
#include (or other) directives.#include directive:/* Include declarations for input/output routines. */
#include <stdio.h>
You should normally use the "" form for your own headers rather than <>.#define PI 3.14159 double pi_twice = PI * 2;
PI will be replaced by the numeric value wherever it is used.#define MAX(A,B) ((A) > (B) ? (A) : (B))…that provide a convenient way to emulate functions without the overhead of a real function call. (See a good book on C for the limitations of this.)
#define JOB_DONE…and are used in conditional compilation [Item 23].
__unix__ is defined only when compiling for a UNIX system, and that the macro __windows__ is defined only when compiling for a Windows system, then we could provide a single piece of code containing two possible implementations depending on the intended target:int file_exists(const char *name)
{
#if defined(__unix__)
/* Use UNIX system calls to find out if the file exists. */
#elif defined(__windows__)
/* Use Windows system calls to find out if the file exists. */
#else
/* Don't know what to do - abort compilation. */
#error "No implementation for your platform."
#endif
}
The most common use of conditional compilation, though, is to prevent the declarations in a header file from being made more than once, should the file be inadvertently #included more than once:/* in the file mydecls.h */
#if !defined(mydecls_header)
#define mydecls_header
typedef int myInteger;
#endif
You should routinely protect all your header files in this way./* We'll assume we're inside some block statement, as in a function. */ int i, j; /*iandjare integer variables. */ int *ip; /*ipis a variable which can point to an integer variable. */ i = 10; j = 20; /* values assigned */ ip = &i; /*ippoints toi. */ *ip = 5; /* Indirectly assign5toi. */ ip = &j; /*ippoints toj. */ *ip += 7; /*jnow contains27. */ i += *ip; /*inow contains32. */
& operator obtains the address of a variable. (The syntax ensures that there is no conflict with the bit-wise ‘and’ operator.) The * operator dereferences the pointer. (Again, the syntax ensures that there is no conflict with the multiplication operator.) A dereferenced pointer can be used on the left-hand side of an assignment, i.e. it is a modifiable lvalue (SQ(el-value)), as in the two examples above.int type, there is also a pointer-to-int type, written int *.float * is the pointer-to-float type. When assigning a pointer value to a variable, or comparing two pointer values, the types must match. Given these declarations:int i, j; float f; int *ip; float *fp;…then
i is of type int, so the expression &i must be of type int *.ip is also of type int *, so you can assign &i to it. &j is of type int *, so it can be compared with &i, and so on.&f is of type float *, so it cannot be assigned to ip, or compared with ip, &i or &j.0), indicating that it points to no object. Do not dereference a null pointer.Many of the standard header files define a macro for a null pointer, NULL, which many programmers may prefer.#include <stdlib.h> int *ip; ip = NULL;
int *ip;
if (ip) {
/* CODE(ip) is not null. */
}
if (!ip) {
/* CODE(ip) is null. */
}
Direct comparisons are also possible (e.g. ip != NULL).0, or the address of an existing object) when used. This badly written function returns a pointer to an integer variable:int *badfunc(void)
{
int x = 18;
return &x; /* Bad - x won't exist after the call has finished. */
}
The pointer returned by badfunc() is invalid.void badswap(int a, int b)
{
int tmp = b;
b = a;
a = tmp;
/* a and b are swapped but they're only copies. */
}
void goodswap(int *ap, int *bp)
{
int tmp = *bp;
*bp = *ap;
*ap = tmp;
}
/* Assume we're in a function body. */
int x = 10, y = 4;
/* Print state of variables. */
printf("1: x = %d y = %d
", x, y);
badswap(x, y);
/* x and y are copied, and the copies are swapped
so x and y are unchanged. */
printf("2: x = %d y = %d
", x, y);
goodswap(&x, &y);
/* Pointers tell goodswap() where we store x and y. */
printf("3: x = %d y = %d
", x, y);
This reports:1: x = 10 y = 4 2: x = 10 y = 4 3: x = 4 y = 10…indicating that
badswap had no effect on the variables given as arguments.. operator. However, the syntax requires parentheses to ensure the correct meaning, but a short form also exists (and is widely used) for convenience:struct point loc;
struct point *locp = &loc;
(*locp).x = 10; /* correct */
*locp.x = 10; /* incorrect; same as *(locp.x) */
locp->x = 10; /* correct, shorter form */
Syntactically, pointers to unions are accessed identically.void goodswap(int *, int *); void (*swapfunc)(int *, int *); /* a pointer calledSince pointers to functions are just values like any other, they can be passed to and returned from functions, so that ‘behaviour’ itself becomes just another form of data.swapfunc*/ int x, y; swapfunc = &goodswap; /* Now it points to a function with matching parameters. */ (*swapfunc)(&x, &y); /* Invokesgoodswap(&x, &y). */
int i; /*The fact that the pointed-to object also holds a pointer does not fundamentally change the behaviour of the pointer that points to it. It just allows a further level of indirection — in practice, you rarely need more than a couple of levels.iholds an integer. */ int *ip = &i; /*ippoints toi. */ int **ipp = &ip; /*ipppoints toip. */ int ***ippp = &ipp; /*ippppoints toipp. */ /* et cetera */
void *. You can convert between the generic pointer type and other pointer types (except pointer-to-function types) whenever you need to:int x; int *xp, *yp; void *vp; xp = &x; vp = xp; Types are compatible. later... yp = vp; Types are compatible.A generic pointer cannot be dereferenced, nor can pointer arithmetic [Item 33] be applied to it.
x = *vp; /* error: cannot dereferenceThe generic pointer type simply allows you to tell the compiler that you're taking responsibility for a pointer's interpretation, and so no error messages or warnings are to be reported when assigning. It is the programmer's responsibility to ensure that the pointer value is interpreted as the correct type.void **/ vp++; /* error: cannot do arithmetic onvoid **/
int *ip; float *fp; void *vp; fp = ip; /* error: incompatible types */ vp = ip; /* okay */ fp = vp; /* no compiler error, but is misuse */Generic pointers are used with dynamic memory management [Item 45], among other things.
int array[10]; /* numbered 0 to 9 */
int i = 6;
array[3] = 12;
array[i] = 13;
int myArray[4] = { 9, 8, 7, 6 };
The size is optional in this case, since the compiler sees that there are four elements in the initialiser. The initialiser must not be bigger than the size if specified, but it can be smaller. Either way, the size must be known at compile time — it can not be an expression in terms of the values of other objects or function calls. In C99, this restriction does not exist.int myArray[4] = { [2] = 7, [0] = 9, [1] = 8, [3] = 6 };
int myArray[4] = { 9, 8, 7, 6 };
int *aep = &myArray[2];
int x, i;
*(aep + 1) = 2; /* Set myArray[3] to 2. */
*(aep - 1) += 11; /* Set myArray[1] to 19. */
x = *(aep - 2); /* Set x to 9. */
*(aep + i) is equivalent to aep[i], and in many contexts, an array name such as myArray evaluates to the address of the first element, which is how expressions such as myArray[2] work (it becomes *(myArray + 2)). The code above could be written as:int myArray[4] = { 9, 8, 7, 6 };
int *aep = &myArray[2];
int x, i;
aep[1] = 2; /* Set myArray[3] to 2. */
aep[-1] += 11; /* Set myArray[1] to 19. */
x = aep[-2]; /* Set x to 9. */
Note that an array name such as myArray can not be made to point elsewhere:int myArray[4]; int i; int *ip; ip = myArray; /* Okay:myArrayis a legal expression;ipnow points tomyArray[0]. */ myArray = &i; /* Error:myArrayis not a variable. */
void fill_array_with_square_numbers(int *first, int length)
{
int i;
for (i = 0; i < length; i++)
first[i] = i * i;
}
…we could write code such as:int squares[4], moresquares[10]; void fill_array_with_square_numbers(int *first, int length); fill_array_with_square_numbers(squares, 4); fill_array_with_square_numbers(moresquares + 2, 7);The second call only fills part of the array
moresquares.int squares[4]; int len = sizeof squares / sizeof squares[0];Because
squares above is the name of an array, we can obtain its length using sizeof squares, which yields the total size as a number of chars. sizeof squares[0] yields the size (in chars) of one element, and since all the elements are of the same size, the ratio of these two sizeofs is the number of elements in the array:void fill_array_with_square_numbers(int *first, int length);
int squares[4];
fill_array_with_square_numbers(squares,
sizeof squares / sizeof squares[0]);
(For arrays of chars, the divisor can be omitted, since sizeof(char) is defined to be 1.)sizeof is only a pointer that happens to point to an element of an array, rather than an array name. Consider that such a pointer looks identical to a pointer to a single object, as far as the compiler is concerned — they don't contain any information about the length. This is why the example function above requires the length as a separate argument: within the function, sizeof first would only give the size of a pointer to an integer, not the length of the array.void fill_array_with_square_numbers(int *first, int length); void fill_array_with_square_numbers(int first, int length);Within the definition of this function,
sizeof first will still equal sizeof(int *), even if we place a length inside the square brackets (such a value is ignored anyway).const instead of finalfinal to indicate ‘variables’ which can only be assigned to once (usually where they are declared). C uses the keyword const with an object declaration to indicate a constant object that can (and must) be initialised, but cannot subsequently be assigned to — it is not a variable, but it still has an address and a size, so you can write &obj orsizeof obj.double sin(double); /* mathematical function sine */ const double pi = 3.14159; double val; val = sin(pi); /* legal expression */ pi = 3.0; /* illegal; not a modifiable lvalue */
const objectsconst pointersconst objectsconst is useful when declaring functions that take pointers or arrays as arguments, but do not modify the dereferenced contents:int sum(const int *ar, int len)
{
int s = 0, i;
for (i = 0; i < len; i++)
s += ar[i];
return s;
}
int array[] = { 1, 2, 4, 5 };
int total = sum(array, 4);
The const assures the caller that the invocation will not attempt to assign to *array (or array[1], array[2], etc), even though the elements of array are modifiable in other contexts.const instead of finalconst pointersconst just like other objects. In these cases, the pointer can't be made to point elsewhere, but does not prevent modification of what it points. Careful positioning of the keyword const is required to distinguish constant pointers from pointers to constants:int array = { 1, 2, 4, 5 };
int *ip = array; /* a pointer to an integer */
int *const ipc = array; /* a constant pointer to an integer */
const int *const icpc = array;
/* a constant pointer to a constant integer */
ipc[0] = ipc[1] + ipc[2]; /* okay */
ip += 2; /* okay */
ipc += 1; /* wrong; pointer is constant */
icpc[1] += 4; /* wrong; pointed-to object is constant */
This example shows a modifiable array whose members are being accessed through four pointers with slightly different types.const instead of finalinline:inline int square(int x)
{
return x * x;
}
If this definition is in scope, and you make a call to it, the compiler may choose not to translate the C call into a machine-code call, but instead replace it with a copy of the function, thus avoiding the overhead of true call.extern:extern int square(int x);If the inline definition isn't in scope, you could provide a normal definition which doesn't actually match the inline definition — but this could lead to confusing behaviour.
char can hold any 16-bit Unicode character. In C, the char type can represent any character in a character set that depends on the type of system or platform for which the program is compiled. This is usually a variation of US ASCII, but it doesn't have to be, so beware. In particular, it could be a multibyte encoding, where a larger set of characters are represented by several char objects, e.g. UTF-8. A basic set of characters, however, are always represented as single chars.LINK_javadoc(java/lang/String.html,java.lang.String) orLINK_javadoc(java/lang/StringBuilder.html,java.lang.StringBuilder), and represent sequences of char.char, and don't exist as a formal type. Functions which handle strings typically assume that the string is terminated with a null character '\0', rather than being passed length parameter. A character array can be initialised like other arrays:char word[] = { 'H', 'e', 'l', 'l', 'o', '!', '\0' };
char another[] = "Hello!";
Note that the second initialiser is a shorter form of the first, including the terminating null character. Such a string literal can also appear in an expression. It evaluates to a pointer to the first character.const char *ptr; ptr = "Hello!";
ptr now points to an anonymous, statically allocated array of characters. Attempting to write to a string literal like this has undefined behaviour, so the use of const ensures that such attempts are detected while compiling.<string.h>. For example, the function to copy a string from one place to another is declared as:char *strcpy(char *to, const char *from);…and may be used like this:
#include <string.h> char words[100]; strcpy(words, "Madam, I'm Adam.");Like many of the other
<string.h> functions, strcpy assumes that you have already allocated sufficient space to store the string.new keyword and its garbage collector. In C, it is available through two functions in <stdlib.h> which are declared as:void *malloc(size_t s); /* Reserve memory for(schars. */ void free(void *); /* Release memory reserved withmalloc(). */
size_t is an alias for an unsigned integral type.)malloc(s) returns a pointer to the start of a block of memory big enough for s chars. It returns a generic pointer which can be assigned to a pointer variable of any type. The memory is not initialised. All such allocated memory must be released when it is no longer required, by passing a pointer to its start to free(). Only pointer values returned by malloc() can be passed to free().sizeof(type). For an array, multiply this by the number of elements required in the array.long *lp; long *lap; lp = malloc(sizeof(long)); lap = malloc(sizeof(long) * 10); /* Now we can access*lpas a long integer, andlap[0]..lap[9]form an array. */ free(lap); free(lp); /* Now we can't. */
malloc() returns a null pointer (0) if it cannot allocate the requested amount of memory.main() functionvoid main(String[])) of a specified class. In C, execution also begins at a function called main, but it has the following prototype:int main(int argc, char **argv);The parameters represent an array of character strings that form the command that ran the program.
argv[0] is usually the name of the program, argv[1] is the first argument, argv[2] is the second, …, argv[argc - 1] is the last, andargv[argc] is a null pointer. For example, the command:myprog wibbly wobbly…may cause
main to be invoked as if by:char a1[] = "myprog";
char a2[] = "wibbly";
char a3[] = "wobbly";
char *argv[4] = { a1, a2, a3, NULL };
main(3, argv);
The parameters are optional (you can replace them with a single void), but main always returns int in any portable program. Returning 0 tells the environment that the program completed successfully. Other values (implementation-defined) indicate some sort of failure. <stdlib.h> defines the macros EXIT_SUCCESS and EXIT_FAILURE as symbolic return codes.<stddef.h><stdlib.h><stdio.h><string.h><ctype.h><limits.h><float.h><math.h><assert.h><errno.h><locale.h><stdarg.h><time.h><signal.h><setjmp.h><iso646.h><wchar.h><wctype.h><stdbool.h><complex.h><inttypes.h><stdint.h><fenv.h><tgmath.h>