1. An Introduction to C Programming (assuming that you already know Java; this is not an introduction to C++)

2. Minimal C program int main ( int argc, char** argv ) { return 0; //comment just like Java } Or int main ( int argc, char* argv[] ) { return 0; /* comment just like Java */ } Or (typically, you aren’t going to change them) int main ( const int argc, const char* const argv[] ) { return 0; } What does main look like in Java? What is used as ‘const’ in Java?

3. Java’s main public static void main ( String args[] ) { }

4. C vs. Java types C –doesn’t init vars (with a few exceptions) –bool, char, short, int, long –float, double –unsigned char –unsigned short –unsigned int –long long –long double Java –does init vars (specifically objects which are defined to be an instance of a class OR arrays; primitive types are NOT initialized and require initialization) –boolean, byte, short, int, long –float, double

5. ASCII output in C (using the standard I/O library) #include //needed for defns int main ( int argc, char* argv[] ) { puts( “hello, world.” ); printf( “hello, world.” ); printf( “hello, world.\n” ); return 0; }

6. ASCII output in C #include //header file w/ definitions int main ( int argc, char* argv[] ) { printf( “hello, %s. \n”, “fred” ); int i = 12; printf( “I am %d years old. \n”, i ); double d = 12.9; printf( “d is equal to %f (d is not equal to %d). \n”, d, d ); return 0; } How can d be both %f and %d?

7. ASCII file output in C (using the standard I/O library) #include int main ( int argc, char* argc[] ) { //open the file for output (erase anything already there!) FILE* fp = fopen( “fred.dat”, “wb” ); assert( fp!=NULL ); //write to the file fprintf( fp, “hello, world.\n” ); //close the file fclose( fp ); fp = NULL; return 0; } Hint: Always open b/binary or binary I/O will act strangely under Windows.

8. ASCII file output format specs %d – an int %c – a char %x – an int in hex %f – a double or a float %s – string Many, many, many others and variations.

9. ASCII file input format specs %d – an int %c – a char %x – an int in hex %f – a float %lf – a double (that’s % ell eff) %s – string Many, many, many others and variations. (see man –s 3c printf)

10. Binary file output in C We will discuss binary file I/O after we discuss pointers. We will discuss input after we discuss pointers as well.

11. I/O in C printf, scanf, gets, and puts perform buffered I/O (to stdin and stdout). fopen, fread, fwrite, fprintf, fseek, fscanf, fgets, fputs, and fclose perform buffered I/O. open, read, write, seek, and close perform unbuffered I/O.

12. C pointers int i=12; –i is a variable. It exists in some memory location. At that memory location is the value of 12. –What is the size of i (in bytes)? printf( “An int is %d bytes. \n”, sizeof(int) ); printf( “i=%d, i occupies %d bytes. \n”, i, sizeof(i) ); –What is the virtual address of i, i.e., where is i in memory?

13. C pointers Let’s introduce an operator (&) that yields the address of a variable. int i = 12; printf( “the address of i is %d. \n”, &i ); printf( “the address of i is %x. \n”, &i );

14. C pointers How do we declare variables that hold pointers (instead of values)? int i=12, j=52; int* ptr = &i; //ptr points to i ptr = &j; //ptr now points to j

15. C pointers Derefencing pointers (getting at what they point to): inti = 12; int*iptr = &i; printf( “i=%d, *iptr=%d. \n”, i, *iptr ); Is *iptr the same as iptr?

16. C pointers Derefencing pointers (getting at what they point to): inti = 12; int*iptr = &i; *iptr = 52; printf( “i=%d. \n”, i ); //What is i’s value?

17. C pointers C pointers can be treated as arrays! #define N 100 int ray[ N ];//note: syntax diff java int* ptr = ray;//same as ptr = &ray[0] for (int i=0; i<N; i++) { ptr[i] = 0; //same as ray[i] = 0 }

18. C pointers C pointers can be treated as arrays. #define N 100 int ray[ N ]; int* ptr = ray; //same as ptr = &ray[0] for (int i=0; i<N; i++) { *ptr = 0; ++ptr; }

19. C pointers C pointers can be treated as arrays. #define N 100 int ray[ N ]; int* ptr = ray; //same as ptr = &ray[0] for (int i=0; i<N; i++) { *ptr++ = 0; }

20. C pointers C pointers can be treated as arrays (most of the time). #define N 100 int ray[ N ]; int* ptr = ray; //same as ptr = &ray[0] for (int i=0; i<N; i++) { *ptr++ = 0; } Every time we ++ ptr, how much is added to ptr? 1?

21. C pointers #include int main ( int argc, char* argv[] ) { int value = 12; int* iptr = &value; printf( "%u \n", iptr ); ++iptr; printf( "%u \n", iptr ); iptr = iptr + 1; printf( "%u \n", iptr ); return 0; } output: 4290771940 4290771944 4290771948

22. C pointers Common pitfall int* ptr1, ptr2; //what (type) is ptr2?

23. C pointers Common pitfall int* ptr1, ptr2; This is actually the same as int *ptr1, ptr2; Which means that ptr2 is an int (not an int*)!

24. C pointers and arrays #define N 100 intray[ N ]; int*ptr = ray; printf( “%d %d \n”, ray[12], ptr[12] ); So, for the most part, pointers and arrays are interchangeable in C.

25. C pointers and arrays Common pitfall (no array bounds check in C) #define N 100 intray[ N ]; int*ptr = ray; printf( “%d %d \n”, ray[N], ptr[1000] );

26. C pointers and arrays So why are these, in effect, the same? int main ( int argc, char** argv ) { return 0; } Or int main ( int argc, char* argv[] ) { return 0; }

27. More C pointers Cast = change from one type to another. double d = 0.7; int i = (int)(d+0.5);//round d int j = (int)d;//don’t round d Sometimes we need to change (cast) from one pointer type to another.

28. ASCII INPUT

29. ASCII input Use scanf (from stdin) and fscanf. printf( “enter two integers: “ ); int n1, n2; scanf( “%d %d”, &n1, &n2 ); Why is ‘&’ necessary?

30. ASCII input Use fscanf to read from ASCII files. FILE* fp = fopen( “input.txt”, “rb” ); assert( fp!=NULL ); int n1, n2; fscanf( fp, “%d %d”, &n1, &n2 ); … How do we know if anything was read?

31. int scanf ( const char *format,... ); int fscanf ( FILE *stream, const char *format,... );

32. ASCII input Use fscanf to read from ASCII files. FILE* fp = fopen( “input.txt”, “rb” ); assert( fp!=NULL ); int n1, n2, count; count = fscanf( fp, “%d %d”, &n1, &n2 ); if (count != 2) { … }

33. Notes about I/O stdin, stdout, and stderr are predefined for you and available for every program to use. –You do not need to define them and you should not open them. –They are already defined for you when you #include.

34. More notes about I/O fprintf( stdout, “hello \n” ); is the same as printf( “hello \n” ); scanf( “%d”, &n1 ); is the same as fscanf( stdin, “%d”, &n1 );

35. More notes about I/O Read in a line of input. char *gets ( char *s ); char *fgets ( char *s, int size, FILE *stream ); What’s the difference between: char buff[ 255 ]; gets( buff ); fgets( buff, sizeof(buff), stdin );

36. DYNAMIC MEMORY ALLOCATION

37. More C pointers Dynamic memory allocation (and deallocation). –malloc int* iptr = (int*)malloc( 10*sizeof(int) ); assert( iptr!=NULL ); –free free( iptr ); iptr = NULL; //good idea, not required Must #include at top. cast

38. BINARY I/O

39. Binary I/O Buffered –fread and fwrite Unbuffered –read and write –We will skip unbuffered I/O (but you are free to use it).

40. Binary input: fread size_t fread ( void* ptr, size_t size, size_t nitems, FILE* stream ); Returns nitems if OK. FILE* fp = fopen( “junk.in”, “rb” ); #define N 100 int buffer[ N ]; int k = fread( buffer, sizeof( int ), N, fp ); What is k?

41. Binary input: fread size_t fread ( void* ptr, size_t size, size_t nitems, FILE* stream ); Returns nitems if OK. #define N 100 int buffer[ N ]; int k = fread( buffer, sizeof( int ), N, fp ); k = fread( buffer, 1, sizeof( buffer ), fp ); k = fread( buffer, sizeof( buffer ), 1, fp );

42. Binary input: fread int buffer[ N ]; int k = fread( buffer, 1, sizeof( buffer ), fp ); k = fread( buffer, sizeof( buffer ), 1, fp ); This (sizeof(buffer)) is an example of where arrays and pointers are NOT the same in C.

43. Binary output: fwrite size_t fwrite ( void* ptr, size_t size, size_t nitems, FILE* stream ); Returns nitems if OK. FILE* fp = fopen( “junk.in”, “wb” ); #define N 100 int buffer[ N ]; int k = fwrite( buffer, sizeof( int ), N, fp ); What is k?

44. 0utput in C (using the standard C++ library) #include using namespace std; int main ( int argc, char* argc[] ) { cout << “hello, world.” << endl; return 0; } You are free to use the standard C++ library but we won’t discuss it in this class.

45. MISC

46. C structures Collection of data (only). –precursor to object –similar to a FORTRAN record Especially useful for message passing. –Ex. { do this operation, here is the data }

47. C structures struct message { enum {OP_CALCULATE, OP_RESULT, OP_EXIT }; intoperation; intparameters[100]; doubleresult; }; Tip: don’t forget ; at end.

48. C structures int main ( int argc, char* argv[] ) { struct message m; m.operation = m.OP_CALCULATE; return 0; }

49. C structures (w/ pointers) int main ( int argc, char* argv[] ) { struct message* m; m = (struct message*) malloc (sizeof(struct message) ); assert( m!=NULL ); m->operation = m->OP_CALCULATE; //most often used (*m).operation = (*m).OP_CALCULATE; //same thing return 0; } Why not sizeof(struct message*)?

50. C++ classes (not required for this course) class Simple3D : public DistanceTransform3D { public: //define public members (data) and methods (functions) here. private:. protected:. };

51. Useful header files #include

52. Compiling C/C++ programs on Linux g++ compiles both C and C++ –Always use g++ for C or C++. Don’t use gcc. It only compiles C and C programs that compile with gcc may not compile with g++. g++ won’t compile 1978 K&R C code but you shouldn’t be coding in that anyway. File name extensions –Always use.cpp for C or C++ code files. (Don’t use.c. It is only for C programs which may compile with gcc but not with g++.) Enter ‘man g++’ for help.

53. Compiling and running C programs on Linux g++ command options -g, -O, -O2, -O3 Optimization level – debug to optimized. -Wall Issue warnings for questionable code. -c Compile (making a.o file) but don’t link. -o Specify output file name. -l (el=lower case L) Specify link library name. Note: use mpic++ (not currently installed on brunel) to compile mpi-based C/C++ programs.

54. Example of compiling C programs g++ junk.cpp Compile and link producing a.out. g++ -c junk.cpp Compile (but don’t link) producing junk.o. g++ -o junk.exe junk.o Link junk.o and produce junk.exe. g++ -o junk.exe junk.cpp Compile and link producing junk.exe.

55. Example of compiling C programs g++ -g -o junk.exe junk.cpp Compile and link producing junk.exe w/ debug information. g++ -O3 -o junk.exe junk.cpp Compile and link producing an optimized version called junk.exe. g++ -O -o fred.exe junk1.cpp junk2.o \ junk3.cpp -lm Compile junk.1pp and junk3.cpp (but not junk2.o) and link producing fred.exe which is somewhat optimized and linked to the math library.

56. Handling C command line arguments argc –count/number of arguments argv –array of strings (the actual arguments) Java doesn’t have argc. Why? In Java, argv[0] is the first argument. In C, argv[0] is the name of the program/command and argv[1] is the first argument.

57. End of C for Java programmers