Java程序辅导

nabg 1
C
If you ever get to work on things like 
the code for Linux, you are more 
likely to use C than C++
C, not C++
• The code for things like
– Linux
– Apache
– GNU software (compilers etc)
– Shells (bash, csh, ksh, …)
are in C not C++.
• Why?
– Mainly historical
– Partly
• Preference by the majority of programmers who work on such code
• Issues with C++ “code bloat” etc
• If you need to read or work with the code of these applications you 
need to be familiar with C’s idioms, and its differences from C++.
Linus is one of those who doesn’t feel 
enthusiastic about C++
On Wed, 5 Sep 2007, Dmitry Kakurin wrote: 
 > When I first looked at Git source code two things struck me as odd: 
 > 1. Pure C as opposed to C++. No idea why. Please don't talk about portability, it's BS. 
*YOU* are full of bullshit. C++ is a horrible language. It's made more horrible by the fact that a lot of substandard 
programmers use it, to the point where it's much much easier to generate total and utter crap with it. Quite 
frankly, even if the choice of C were to do *nothing* but keep the C++ programmers out, that in itself would be a 
huge reason to use C. In other words: the choice of C is the only sane choice. I know Miles Bader jokingly said "to 
piss you off", but it's actually true. I've come to the conclusion that any programmer that would prefer the project 
to be in C++ over C is likely a programmer that I really *would* prefer to piss off, so that he doesn't come and 
screw up any project I'm involved with. C++ leads to really really bad design choices. You invariably start using the 
"nice" library features of the language like STL and Boost and other total and utter crap, that may "help" you 
program, but causes: ‐ infinite amounts of pain when they don't work (and anybody who tells me that STL and 
especially Boost are stable and portable is just so full of BS that it's not even funny) ‐ inefficient abstracted 
programming models where two years down the road you notice that some abstraction wasn't very efficient, but 
now all your code depends on all the nice object models around it, and you cannot fix it without rewriting your 
app. In other words, the only way to do good, efficient, and system‐level and portable C++ ends up to limit 
yourself to all the things that are basically available in C. And limiting your project to C means that people don't 
screw that up, and also means that you get a lot of programmers that do actually understand low‐level issues and 
don't screw things up with any idiotic "object model" crap. So I'm sorry, but for something like git, where 
efficiency was a primary objective, the "advantages" of C++ is just a huge mistake. The fact that we also piss off 
people who cannot see that is just a big additional advantage. If you want a VCS that is written in C++, go play with 
Monotone. Really. They use a "real database". They use "nice object‐oriented libraries". They use "nice C++ 
abstractions". And quite frankly, as a result of all these design decisions that sound so appealing to some CS 
people, the end result is a horrible and unmaintainable mess. But I'm sure you'd like it more than git. 
Linus
C
• This small segment of CSCI131 will illustrate
– Some features of C
• Particularly those where C seems confusingly different 
from the C++ that you are studying in CSCI114 and 
CSCI124
– Some of the C libraries
• E.g. stdio instead of C++’s iostream
Use an
Integrated Development Environment
IDEs enhance your productivity as 
programmers!
A side note!
NetBeans IDE
• All illustrative examples will have been created using the 
NetBeans IDE
– This IDE allows you to create
• Java programs
• PHP programs
• Javascript programs
• C++ programs
• C programs
– NetBeans itself is written in Java and runs on Linux and Windows
• There are instructions at netbeans.org that tell you how to set it up on Windows using cygwin
or mingw (or Microsoft’s C/C++ tools) for C/C++ projects
A side note!
nabg 2
Netbeans tutorials on the web
• There are tutorials at netbeans.org and on youtube.
It will take you a couple of hours to learn how to use the IDE.
You will become much more productive in your subsequent 
development work, because the IDE can help
– It checks the syntax of your code as you type it in and highlights errors (e.g. 
missed parentheses, missing quote, comma or semi‐colon)
– It has built in details of the standard libraries – and can prompt you when you 
are writing code calling a standard function (showing argument list etc)
– It understands “makefile” syntax a lot better than you and looks after these 
build files
– It speeds the edit‐compile‐edit‐compile‐edit‐run‐edit‐compile‐run cycle
A side note!
NetBeans – use in other subjects
• NetBeans is used
– CSCI110 – PHP projects
– CSCI222 – C++ projects and C++ unit testing
– CSCI399 – Java web and PHP/Zend projects
– CSCI398 – Enterprise Java projects
• NetBeans used to be used in CSCI213 for Java but the current 
lecturer uses Eclipse on his own computer, and so requires the use 
of that IDE for this subject (so you have to learn both)
– Both Eclipse and NetBeans are free – download from Internet
• Some students prefer alternative open‐source or proprietary development 
environments – but these won’t be deployed in the lab.
• The Microsoft Visual studio products are excellent development environments for 
those developing Windows specific code – but these products aren’t currently used 
in any CS subjects.
– Microsoft offers free “developer editions” of its Visual Studio projects – these are fine for student use, they omit some 
‘enterprise level’ features like load testing
A side note!
NetBeans on Windows
• Many of the screenshots will show
– NetBeans 7.3 on Windows XP
– Cygwin as the Windows hosted Unix subset
• This configuration was used because it was convenient for capturing 
screenshots and pasting into a Windows PowerPoint file.
• Labs will use Linux with a more recent version of NetBeans
• If you want to keep your computer as a Windows machine (presumably for games 
etc) then
1. Best option is make it dual boot with a version of Linux and install the gnu 
development tools on your Linux along with Java and NetBeans from Oracle
2. Not so good – install Linux as a virtual machine within your main Windows system and install same 
development software in this virtual machine
3. Less good choice – only really appropriate when needing to get screen shots for PowerPoint
1. Install Java and NetBeans from Oracle on Windows
2. Install either cygwin or mingw on your Windows machine 
3. Configure your environment variables (full instructions at netbeans.org) so that NetBeans can find the cygwin/mingw
setup
A side note!
C
Not quite the C++ that you know
(and love?)
C++ is not a superset of C.
C
• For a start, you don’t have –
– Classes
– Templates
– Exceptions
– Nor
• Type secure I/O with the iostream library
– Compiler checking code using iostream library can determine data types and avoid errors 
that can occur when a careless programmer uses the stdio library
• New and delete operators
• Pass by reference
• bool as a standard type
• STL data types like string or vector
• …
Of course, 100‐level students haven’t met templates and exceptions and have had only the most rudimentary introduction to classes –
so you won’t miss these (and they are the really good features of C++).
C
• You do have –
– Lots more explicit manipulation of pointers
• When in C++ you pass arguments by reference, you are actually passing pointers –
and the code of the function with reference arguments is actually dereferencing 
these pointers; C++’s “pass by reference” is just a little “syntactic sugar” to make 
pointer use more palatable
• In C, you are explicit in your use of pointers
– Beginners often get confused with the syntax of expressions involving dereferencing of 
pointers
– Lots more use of the “address of” operator &
• When invoking functions requiring “call by reference”, you have to make clear that 
you are passing the address of a variable and not its value
– More #define macros and lots of typedefs
• In C, typically define all your constants in macros
– Less flexibility as to where you can define local variables
– ….
nabg 3
C –
2 trivial differences from the C++ you know
• Comments 
– You were limited to
/* helpful explanatory comment */
(traditionally, there were no “line comments” using //)
But it appears that // comments have been retrofitted (or at least gcc now accepts them 
whether or not they are in standard)
• Local variable declarations –
– All local variables of a block (function or nested block) must be declared 
at the start of that block, 
and in particular for(‐‐‐;‐‐‐;‐‐‐) cannot be used to declare a local scope variable 
as you are used to in C++ (e.g. for(int i=0;i<10;i++) is illegal in C)
Demos 1
Mostly stdio & stdlib
Demo 1
• Create a C project …
Pick C (not C++, and
definitely not FORTRAN)
Choose C/C++ Application
Demo 1 project
• NetBeans generated project
– Has a main.c generated, along with a makefile (and other project 
related housekeeping files)
– NetBeans assumes that 
project will use stdio
and stdlib – so inserts
the #include directives 
on these header files
Header files
• C and C++ use header files in the same way
– Sometimes there are slightly different versions of the same header file for C and for 
C++;
more often, there are conditional compilation directives in the header files that 
separate any specifically C related material from any specifically C++ material
– C’s header files all have names like stdio.h
• C++ specific headers vary – you may get .H, .hpp or simply no extension on the 
file name
• Role of a header file:
– Declare signatures of functions that are in a library file that can be 
linked with your programs code
• Also, declare types, #define constants, typedefs, and occasionally global 
variables
– Needed so that the C/C++ compiler can check that any calls that 
your code makes to these library functions include the 
necessary arguments
You can view the header files …
• Mouse over the #include header file, and right click
• This is sometimes an easy way of checking what 
functions are defined in a particular header file,
but …
If you ever need to find an actual header file for some reason, try looking in
/usr/include or /usr/local/include; there may be subdirectories with C++ specific
headers.
nabg 4
Header files are often hard to read!
• Most modern header files are complex
– Header files tend to depend on other header files so there 
may be a series of #include statements bringing in other 
function and MACRO definitions
– Macros are commonly used
– There will be numerous conditionally compiled sections 
expressing things like
If compiling ANSII C then declare the functions like this … 
else if compiling C++ then declare the functions like this …
If compiling for Cygwin use this specific modified version
stdio.h has declarations for the
functions:
fopen, fclose, fflush, tmpnam, …
fgetc, fputc, fgets, …
_EXFUN( name, parameter list) is macro that changes how a function is 
actually declared; it will arrange the declarations to suit the environment –
e.g. old C function declarations were like this (arguments listed after () parens!)
char* fgets()
char* str; 
int num;
FILE* file;
Modern C function declaration would be
char* fgets(char* str, int num, FILE* file);
Function documentation
• C (and most C++) documentation still uses the 
old “man” page listings 
A man page in a cygwin terminal on Windows
man
• man (short for manual) is the Unix/Gnu/Linux utility 
that displays manual pages
– Illustration of use in cygwin console:
man fgets
– It pages through the documentation
SYNOPSIS
#include 
char *fgets(char *BUF, int N, FILE *FP);
#include 
char *_fgets_r(struct _reent *PTR, char *BUF, int N, FILE *FP);
DESCRIPTION
Reads  at most N‐1 characters from FP until a newline is found. The characters including to the newline are stored in BUF. The 
buffer is terminated with a 0.
man pages
• Text with markup for the nroff formatter (one of the programs in Unix version 1)!
– Why not convert to HTML and make them easier to read, and a lot 
easier to follow the cross references that exist in most man pages?
Tradition!
man is the system that all past Unix/Linux programmers have used –
the next generation of programmers must follow this tradition.
Markup tags
.SH like HTML’s 

.PP like HTML’s 

Again, if you ever want to find the files, try /usr/man
fgets etc
• Anyway, I now know that I can use an fgets function in my 
Demo1 program and it will be found when the stdio library file 
is linked to my code.
• What’s this?
– It is a #define constant
• Included in stdlib
(where also find functions like atoi)
• Why does program return an int value?
– For shell scripting!
• You can write a script that will run a sequence
of programs; script can have loops, and can have
conditionals. A shell script may want to test 
results returned by programs – results that indicate
if all is well (and script to continue) or something
went wrong
nabg 5
Demo1
• Begin by reading and writing strings
– gets and puts
SYNOPSIS
#include 
char *gets(char *BUF);
DESCRIPTION
Reads  characters from standard input until a newline is found.  The characters up to the newline are stored in BUF. The 
newline is discarded, and the buffer is terminated with a 0.
This is a _dangerous_ function, as it has no way of checking the amount of space available in BUF. One of the  attacks used  by the  Internet  Worm  of  1988  used  this  to overrun a buffer 
allocated on the stack of the finger daemon and overwrite the return   address, causing the daemon to execute code downloaded into it over the connection.
SYNOPSIS
#include 
int puts(const char *S);
DESCRIPTION
`puts' writes the string at S (followed by a newline, instead of the trailing null) to the standard output stream.
Demo1 ‐ code
• Enter code in NetBeans editor 
• In Projects pane, select project and right‐click select build; 
NetBeans will display steps in makefile
– gcc runs first as compiler, then as link loader
Compiling main.c to main.oLinking with standard C libraries to produceexecutable file demo1
Demo1
• NetBeans conventions
1. Builds a “debug” version of the code
• This has symbol table information (names
of functions etc) kept to simplify debugging
2. Creates the .o files (compiled, linkable
files) in a build subdirectory
• Has Debug/Release subdirectory
– Another “platform” subdirectory
» .o files go here
3. Creates a dist (distribution) directory (again with version 
and platform subdirectories)
• Linked .exe file goes here
Demo 1 – it runs
• Select project, right‐click and select Run
Demo1 – lots of Unix conventions!
• In Unix
– The differences between disk files and character devices, like the 
keyboard and teleprinter, is hidden from the application layer
• Unix provides FILE structs
– Maintained by the OS, accessed in applications through FILE* pointers 
– The OS transfers data through buffers associated with the structs either to 
character devices or to disk files
• Each program gets an array of these structs (well, it’s really a bit more complex than 
that)
– Defaults
» [0] – gets mapped to your console keyboard character device
» [1] – gets mapped to your console “teleprinter” character device,
as is [2]
– But you can use the shell to change these mapping to use disk files when 
you give the command to run the program
stdin, stdout, stderr
• FILE* variables stdin, stdout, and stderr are defined (either in 
stdio.h or one of the header files that it includes)
– These predefined variables reference entries [0], [1], and [2] in the 
OS’s collection of FILE structs for the program.
• What is a FILE struct like?
You can get some idea by looking at header files
C++ iostream classes are just wrappers, holding some extra data along with pointers to structs supplied
by the OS; cin, cout, and cerr are iostream classes wrapping stdin, stdout, and stderr
Only Linux kernel writers would 
really need to know what is in 
a FILE struct
nabg 6
Demo 1 again
• The code would be a little clearer if it made explicit 
use of stdin, stdout –
– Using functions fgets and fputs rather than gets and puts
• fgets – safer, you specify a limit on the number of characters so 
you have less chance of overrunning your character array
• fputs – doesn’t automatically add a newline (as done by puts())
Shell redirection
• You should have learnt this in CSCI114.
• The program can be made to read from a file and write to a file –
you probably had an example something like:
$ ./a.out < input1 >outputfile
• Generally, in NetBeans such command line arguments can be specified in a “properties” 
dialog for the project – but redirection doesn’t work properly with a 
NetBeans/Windows/cygin configuration
• So the files were moved to the banshee server
Demo1b
atoi and itoa
atoi and itoa
• Function atoi is still around – it’s in stdlib.
• Function itoa has disappeared from the standard C 
libraries
– An implementation of itoa was one of the examples in 
Kernighan and Ritchie’s book on the C language (1978)
K&R’s code has been modernised for this illustration
Demo1b Demo1b
• Executable size (~56kbyte) is a little larger than the 
assembly language version (that would have been less 
than 512 bytes)
– There are overheads associated with high level languages
nabg 7
Demo1c
Formatted I/O using scanf & printf
printf & scanf
• Functions like fgets and fputs are OK for simple string inputs 
and prompts,
but they aren’t really what you’d want in a program that read 
lots of data and needed to produce well formatted tabular 
output.
• The stdio library provides some more sophisticated functions –
– scanf, printf, and variants like fprintf and sprintf
Some C++ programmers prefer to use these functions from the stdio library rather than the methods of the iostream library.  The 
stdio library is noticeably smaller, and it tends to work a bit better with socket (networking) I/O streams.  But it is less safe!
The way arguments are provided to these functions – a format string and argument variables – means that a C compiler will not 
spot incompatibilities (e.g. integer format specified for a float value); errors can arise at run‐time.  C++’s iostream allows for more 
complete compile time checks.
printf
NAME
printf, fprintf, sprintf ‐ print formatted output
SYNOPSIS
#include 
int printf(const char *restrict format, /* args*/ ...);
int fprintf(FILE *restrict stream, const char *restrict format,  /* args*/ ...);
int sprintf(char *restrict s, const char *restrict format,  /* args*/ ...);
DESCRIPTION
The printf() function places output on the  standard  output stream stdout.
The fprintf() function places output on the named  output stream stream.
The sprintf() function places output, followed by  the  null byte  (\0),  in  consecutive  
bytes starting at s; it is the user's responsibility  to  ensure  that  enough  storage  is 
available.
From man page (man 3c printf)
Printf (& friends)
• Each of these functions converts, formats,  and  prints  its 
arguments under control of the format. 
• The format is a character string. 
• The format is composed of zero or more directives: 
– ordinary characters, which are simply copied  to  the output  stream  
– and conversion specifications, each of which results in the fetching  of  
zero  or  more  arguments.  
• In format strings containing  the  %n$  form  of  conversion 
specifications,  numbered arguments in the argument list can be 
referenced from  the  format  string  as  many  times  as required.
• In format  strings  containing  the  %  form  of  conversion 
specifications,  each  argument in the argument list is used  exactly 
once.
From man page (man 3c printf)
Printf (& friends)
• Conversion Specifications
• Each conversion specification is introduced by the % character  or  by the 
character sequence %n$, after which the following appear in sequence:
– An optional field, consisting of  a  decimal  digit  string  followed  by a $, specifying the next 
argument to be converted. If this  field  is  not  provided,  the  args following the last argument 
converted will be used.
– Zero or more flags (in any order), which modify the meaning of the conversion specification.
– An optional minimum field width. If  the  converted value has fewer bytes than the field 
width, it will be padded with spaces by default on  the  left;  it will be padded on the right, if 
the left‐adjustment flag (‐), described below, is given  to  the  field width.  The field width 
takes the form of an asterisk (*), described below, or a decimal integer.
– If the  conversion  specifier is  s,  a  standard conforming  application interprets the field 
width  as  the  minimum  number  of bytes  to  be  printed…
• And so on for another ~eleven pages
From man page (man 3c printf)
An easier introduction to printf
http://www.cplusplus.com/reference/cstdio/printf/
• int printf ( const char * format, ... );
• Print formatted data to stdout
• Writes the C string pointed by format to the standard output. If format
includes format specifiers (subsequences beginning with %), the additional 
arguments following format are formatted and inserted in the resulting 
string replacing their respective specifiers.
Parameters
• format C string that contains the text to be written to stdout. 
It can optionally contain embedded format specifiers that are replaced by 
the values specified in subsequent additional arguments and formatted as 
requested.
A format specifier follows this prototype: 
%[flags][width][.precision][length]specifier
The value returned is the total number of bytes written – it is extremely rare to see
this value used by a program; most C code treats printf as if it were void printf(…)
nabg 8
Length modifiers –
int format can be used with short, standard and long int – modifier has to say which
similarly f format can be used with float and double – again modifier needed
Examples of printf
Printf tutorials
• Lots on web – including 
– http://www.codingunit.com/printf‐format‐specifiers‐format‐
conversions‐and‐formatted‐output
printf
• Not really too hard
– Function call
• Address of format string, and values of arguments pushed onto stack
• Implementation of printf
– Interprets format string, fetching other arguments from stack frame
• Lots of opportunity for error –
– Number of arguments less than number of % fields – well just grab 
whatever garbage bits there are at top of the stack!
– % field specifier says long integer (8 byte), argument was 4 byte integer –
well just grab another 4 bytes from stack (so value of this field is wrong, as 
are all subsequent fields)
• Some of those format strings with width and precision can get a 
little confusing.
nabg 9
scanf and friendsFrom man page (man 3c scanf)
NAME
scanf, fscanf, sscanf‐ convert formatted input
SYNOPSIS
#include 
int scanf(const char *restrict format...);
int fscanf(FILE *restrict stream, const char *restrict format...);
int sscanf(const char *restrict s, const char *restrict format...);
DESCRIPTION
The scanf() function reads from the  standard  input  stream stdin.
The fscanf() function reads from the named input stream.
The sscanf() function reads from the string s.
int scanf ( const char * format, ... );
Read formatted data from stdin
Reads data from stdin and stores them according to the parameter format into the locations pointed by the additional arguments.
The additional arguments should point to already allocated objects of the type specified by their corresponding format specifier
within the format string.
Parameters
format 
C string that contains a sequence of characters that control how characters extracted from the stream are treated:
Whitespace character: the function will read and ignore any whitespace characters encountered before the next non‐
whitespace character (whitespace characters include spaces, newline and tab characters). A single whitespace in the format
string validates any quantity of whitespace characters extracted from the stream (including none).
Non‐whitespace character, except format specifier (%): Any character that is not either a whitespace character (blank, newline 
or tab) or part of a format specifier (which begin with a % character) causes the function to read the next character from the 
stream, compare it to this non‐whitespace character and if it matches, it is discarded and the function continues with the next 
character of format. If the character does not match, the function fails, returning and leaving subsequent characters of the 
stream unread.
Format specifiers: A sequence formed by an initial percentage sign (%) indicates a format specifier, which is used to specify the 
type and format of the data to be retrieved from the stream and stored into the locations pointed by the additional arguments.
A format specifier for scanf follows this prototype:
%[*][width][length]specifier
Where the specifier character at the end is the most significant component, since it defines which characters are extracted, their 
interpretation and the type of its corresponding argument:
scanf
scanf scanf
• scanf requires
– A format string
– Addresses for where the input data values are to be 
stored
• C convention (and C++) –
– arrays are always passed by reference (i.e. the address of [0] is 
used if an array name appears in an argument list
– By default, other data elements are passed by value (a copy is 
made on the stack)
• So –
– A char[], string, argument will just appear as its name
– All other arguments for scanf must be addresses – so use & 
(address of) operator with argument names in call
scanf
Return Value
On success, the function returns the number of items of the argument list 
successfully filled. This count can match the expected number of items or 
be less (even zero) due to a matching failure, a reading error, or the reach 
of the end‐of‐file.
If a reading error happens or the end‐of‐file is reached while reading, the 
proper indicator is set (feof or ferror). And, if either happens before any 
data could be successfully read, EOF is returned.
Relatively few C programs actually check the return value from scanf – they simply
assume that everything is fine and that the expected number of items were read.
Scanf ‐ examples
&yob,
&height,
&weight
‐ Using “address‐of” 
so as to pass addresses
of variables to scanf;
but “name” is an array
so compiler knows to
pass its address
nabg 10
There is more to stdio
fopen
fopen
FILE * fopen ( const char * filename, const char * mode );
Open file
Opens the file whose name is specified in the parameter filename and 
associates it with a stream that can be identified in future operations by 
the FILE pointer returned.
The operations that are allowed on the stream and how these are 
performed are defined by the mode parameter.
The returned stream is fully buffered by default if it is known to not refer 
to an interactive device.
fopen
There is, of course, an fclose(FILE*) function that allows you to close a file that is no longer needed.
Files are closed automatically on program termination.  But generally best to close files as soon
as you are finished using them.
Demo1e –
fopen – write, append, read
fopen(filename, “w”);
Write mode – if file does exist 
then empty it; if file didn’t 
exist then create it.
fopen(filename, “a”);
Append mode – if file does 
exist then open it and adjust
access pointer so it’s at end of
existing content; if file didn’t 
exist then create it.
Close file after each stage – C doesn’t have automatic destructors so the fact that outFile
goes out of scope doesn’t have any consequence.
Open for reading
nabg 11
stdio
other operations on FILE*
• fseek,ftell, fread, fwrite
– These functions from stdio are useful when working with a 
binary file that contains data for structs
• There will be an example later – in the section on C structs.
• fflush
– Ensures that any output buffered for this file is written
• Useful in a couple of situations:
– Working with a network connection
» By default, OS may wait for a certain minimum amount of data before 
sending a message on the network; if your message is smaller, it just 
waits – so fflush it to make it go
– Tracing a program with lots of fputs(logfile, “Got to function …”) – if you don’t 
fflush after fputs and the program dies, your log file won’t really show how far 
you got
stdio
others
• int feof(FILE* stream)
– Returns a non‐zero value if “end‐of‐file” is set onf the FILE struct (which 
will have happened if a read operation tried to read beyond end of file)
• int ferror(FILE* stream)
– Returns a non zero value if the FILE struct has a flag set indicating that an 
error has occurred (e.g. conversion failure in fscanf)
• int rename(const char *old, const char *new)
– Change name of file
• int remove(const char *filename)
– Deletes the file
• tmpnam() and tmpfile() 
– Creating temporary files
And also in stdlib …
Demos 1 was supposed to cover stdlib as 
well as stdio
stdlib
• It’s a bizarre mixture of assorted functions
– atoi (also atof, atol)
– rand() and srand()
• Pseudo‐random number generator and function that sets start value
– abs()
• Absolute value
– exit(int status)
• Terminate program – returning status value to shell
– bsearch() and sort()
• C style generic functions that work with arrays of data structures,
you supply the function to compare your structs;
for bsearch(), your array must already have been sorted – it’s doing a binary 
search using a key value that is to be compared with key field in structs
– …
The C libraries just grew naturally as people standardized useful functions and added them to libraries.
But that has the unfortunate consequence of a lack of namespace control – function names are
arbitrary, there is no way of identifying the library to which a function belongs.
Java and C# have cleaned this up.
stdlib
• And, in addition to those, stdlib has
–malloc
– free
• These are C’s functions used to claim and release 
space on the heap (free store);
they are wrappers for the lower level system calls 
(brk())
– C++’s new and delete operators are smart wrappers for 
malloc and free
• Very important – examples later with C structs.
Demos 2
C’s struct
nabg 12
struct
• structs in C are not the same as structs in C++
– Of course, in C they cannot have any member 
functions – they are simply collections of data 
elements
• There is another difference – can illustrate 
with a simple struct point:
struct point {
int x;
int y;
};
struct
C++
C++ and C projects
C++ version compiles
and runs; the C++
compiler is happy with
our variable declarations
for “origin” and “firstquad”
struct
C
C++ and C projects
C compiler rejects this
code!
struct
C
C’s struct
• In C, the definition of point created a data 
type whose name is “struct point”
C compiler is happy
to compile this version,
and it runs ok.
C’s struct
• Everywhere you want to use a variable of a struct
type in C, you will need the struct keyword
void planroute(struct point startpt , struct point endpoint)
{
struct point waypoints[1000];
…
• This gets a little tedious
• So, C programmers will usually define a typedef –
typedef struct point Point;
nabg 13
C’s struct and typedef
• C compiler is happy with that version …
typedef
• All that the compiler does is a text substitution
– At an early stage in the compilation process, it changes the input text;
replacing each instance of Point with struct point.
• It’s not really defining a type
typedef unsigned int diskpos;
typedef unsigned int clockcount;
…
clockcount timer;
diskpos wantedblock;
…
val = timer + wantedblock;
• The compiler will be quite happy to let you add clockcount
values to diskpos values – because they are the same type 
unsigned int!
Demo2b
Structs and binary files with stdio
Structs and more
• This example involves a couple of contrived programs 
that are intended to demonstrate
– struct
– More scanf & printf
– Some functions from 
– Some limited use of malloc and free
– Argument passing
– Use of binary file
– …
• The example involves a file of “employee records”
Projects
Two multi‐file projects 
more elaborate makefile and build process – but the IDE
will look after that!
Sharing files between projects in NetBeans:
The projects require the same “Employee” record structure.
This was defined – in files employee.h & employee.c – in the
first project Demos2b1.
When project Demos2b2 was created, these two files were
“copied & pasted” into the new project.  But they weren’t 
copies – they are simply references to the existing files.  (It
can make things quite confusing if you really are trying to copy a
file and then change it  ‐ you are actually changing the original.
It also requires a change in the #include statements.)
Netbeans authors felt that file sharing amongst projects was
common enough to justify doing it this way.
NetBeans oddity
Those “Header Files” and “Source Files” folders –
they aren’t real file directories – simply a fiction
for maintaining a clean view of project
File structure is:
nabg 14
Demos2b1 & Demos2b2
• Demos2b1
– Read a text file with details of employees and store the 
data as binary records in a file.
• Demos2b2
– Reads the binary record file, and constructs an index 
employee‐id => disk_location
– Then a simple interactive loop where user can ask to see a 
particular employee’s record and possibly pay them more 
money (disk file gets updated)
• Not a full scale payroll application – just a little code to 
provide for more examples of C constructs.
C features
• Input with fscanf
– Some oddities
• Reading in a complete line that represents a string with space 
characters
– Normally, when reading string variables in C/C++ the reader stops at 
a white space character
• Noting errors on inputs
• fseek, ftell operations
• fread and fwrite for binary file
• malloc and free
Section saying “This is a C style header” – just in case
the file gets used in a C++ project (the C++ compiler has to
follow C conventions when dealing with this code).
The code uses FILE* ‐ so that’s got to be defined, so must
include stdio.h; but the compiler doesn’t have to read the
stdio.h file again if it has already included it.
Need some integer constants; but cannot have
const int NAMELENGTH = 32;
in a header file (because that defines a global
‘variable’, and if the header file is included more
than once you’ll end up with a multiply defined global)
So use old fashioned #define
Using functions from  (strcmp – string comparison function)
nabg 15
Using functions (and typedef and struct data types) from time.h
time_t is a typedef variant of long (at least on this machine – the definition seems to be
in machine/types.h which gets #included from sys/_types.h which gets #included from
sys/types.h which gets #included from time.h ‐
are you still surprised why compilations can take a long time – think of all the files that must be opened and read!
struct tm represents a timestamp with fields like day, month, and year (actually year offset from 1900)
Function time() – reads system clock and fills in variable whose address is passed
Function localtime() – fills in a static data structure with the timestamp data that match time 
value passed as reference argument, and returns a pointer to this static area.
In fprintf statements ‐ %ld when argument is a long, %d when argument is a standard int
Part of data file …
In NetBeans, text data files can be added to a project by selecting New File/Other/empty file
and giving the file a name like empdata.txt
Demo2b1
• Open a file for binary write
• Loop
– Zero out an Employee record
– Read in data from file, copy strings into record being careful in case 
they are too long
– Write the record as a binary record.
Using stdio (fscanf etc),
stdlib (exit, also NULL
via further #includes),
and string – for string
copy functions.
Those are all standard C library,
so  are #include <…>.
Also need employee.h
from this project
Opening (& later closing) files
Then a “forever” loop where read, check, and write records.  The forever loop
is exited when reach end of the text input file.
Finally, close files and return ‐
Binary file ‘b’ –
if you don’t specify binary
then some operating systems
will change the data as they
are written – e.g. a byte that
matches the ‘\n’ character may
get changed to ‘\r’ or be 
replaced by two bytes “\n\r”
Read text file
1
2
1 – read 2  long integers, then consume anything else (trailing whitespace) on current line
2 – read a complete line into buffer – something like “Chief Executive Officer”
Zero out struct;
C doesn’t have
constructor like C++;
so you need to clean
out any struct you use
strncpy length limited copy, there’s only space for NAMELENGTH‐1 characters (and
a nul character) in the firstname field – so don’t try to put any more!
Note use of & ‐ address of operator –need to pass addresses of fields in person struct
validate
nabg 16
Binary write Demo2b1 runs
The Unix command od (octal dump) offers
a means of getting some view of the contents
of a binary file;
here it is in cygwin
Demo2b2
• Construct index (employeeid => record position)
• Interactively view and update records
• Index requires another little struct
• When including employee.h, the #include statements must make clear 
that it’s the one in project Demo2b1
Index
• Index
– An array of pointers to small structs
• Employee identifier
• File position as obtained by ftell()
– Create the structs as needed
• malloc
– Call – you request a block of bytes of specified size
– Return – a void* (pointer to anything) value, the address of the start 
of the block of bytes
» In C, this can be assigned to any pointer type
– (No check that number of employees doesn’t exceed maximum specified for 
array – this check left as exercise!)
malloc
nabg 17
Fill the array with NULL pointers
Open the binary file just for
reading
Read a block of the right number
of bytes into the Employee struct x
Create a new indexrec struct
in heap (equivalent to a C++
new operation, but unchecked
error prone low level style)
Fill in fields of struct
Add to index array
Use ftell() to get file byte address of start of next record.
ftell
Finding entry in index Demos2b2
• Demos2b2
– Reads the binary record file, and constructs an index employee‐id => 
disk_location
– Then a simple interactive loop where user can ask to see a particular 
employee’s record and possibly pay them more money (disk file gets 
updated)
interact
• Open binary file for update
• Loop:
– Prompt for and read employeeid
– Find position in file using index
– Allocated space for record
– Read in record
– Display record
– Read update info
– Write record
– Release space used for record
Open binary file for update –
rb+
Prompt for employee id
Look up location in
index
nabg 18
fseek
Seeks to correct point in file
Allocates a heap structure for the record
Reads in the block of bytes
Display, & get update data
Write the block of bytes back
Free the block of bytes that were allocated in the heap
Could have used a local stack variable for the Employee record – just using this approach to
illustrate free()
free Demo2b2 runs
Compilation and linkage
• Bit more complex for multi‐file programs, more convenient if you can 
leave it to an IDE to sort things out
– 3 gcc compile steps
• For Demos2b1/employee.c
• Demos2b2/indexrec.c
• Demos2b2/main.c
– gcc link step – employee.o, indexrec.o, main.o
Demo2c
This time use really low level I/O
Use the standard Unix system calls
unistd.h & fcntl.h
nabg 19
stdio, FILE and the file system
• stdio library with its FILE structures provides some 
useful features
– Formatting, string handling, buffering
• But you can simply use the underlying file system
– Access via fcntl.h and unistd.h
• These have the function signatures for the standard Unix operating 
system calls
unistd.h
• Wikipedia explains
“In the C and C++ programming languages, unistd.h is the name of the header file 
that provides access to the POSIX operating system API. It is defined by the POSIX.1 
standard, the base of the Single Unix Specification, and should therefore be 
available in any conforming (or quasi‐conforming) operating system/compiler (all 
official versions of UNIX, including Mac OS X, GNU/Linux, etc.).”
• Three main groups of functions
– File structure related
– Process related
– Interprocess communications
unistd.h
NAME
unistd.h ‐ standard symbolic constants and types SYNOPSIS
#include 
DESCRIPTION
The  header defines miscellaneous symbolic constants 
and types, and declares miscellaneous functions. 
System calls like these were documented in the 2nd chapter of the original Unix manual –
so documentation got via man 2 cmdname.
unistd.h : File
• Unix/linux systems allocate each process an array of file descriptors 
(one of fields in a FILE is the index of the file descriptor its using)
– You see a file descriptor just as an index number
• 0 = stdin, 1 = stdout, 2 = stderr;
• Other values – as returned by open
– System knows what they really are
• File calls
– creat(),  open(), link(), unlink(), dup(), close()
• creat(), open() – these are in fcntl.h along with constant declarations used to specify 
‘read‐only’, ‘write’ etc
• creat() ‐ creat() is equivalent to open() with flags equal to 
O_CREAT|O_WRONLY|O_TRUNC.
– read(), write(),
– lseek()
– stat(), fstat(), iocntl()
– access(), chmod(), chown(), umask()
unistd.h : File
• creat(), link(), unlink(), dup(), close() , open()
– Open, close – obvious; open takes filename and int constant for mode
– dup – duplicate an entry in the sytems file descriptor table (gives you two file 
descriptors referencing same file – sometimes used in effect to renumber a I/O stream, 
sometimes deliberately used with different permissions)
– link() and unlink() – create and destroy 2nd‐ry entries in file directories
• read(), write(),
– Transfer blocks of bytes – less buffering than with FILE* fread/fwrite
• lseek()
– Move to position in file (obviously doesn’t work with character special devices like keyboard – for 
keyboard only interpretation would be forget that was written (seeking back) or guess what will be written 
(seeking forward))
• stat(), fstat(), 
– Ask for details about file (size etc)
• iocntl()
– Change way device is handled etc – e.g. non‐blocking I/O
• access(), chmod(), chown(), umask()
– Change properties of file in directory – you’ve used these as shell commands
Can work at file descriptor level
• Use open – get an integer file descriptor
• Use read/write – pass file descriptor as arguments
• Use lseek – position file
– No tell, if working at this level you are expected to keep 
track of file position for yourself!
nabg 20
Interact routine using system calls 
…
…
Integer file descriptor,
obtained by open() call (mode is
read and write)
Remember to close your file
descriptor!
File descriptor table is finite – at least 16 entries, these days more – but if you don’t
invoke close on the file descriptor when you’ve finished with a file then you may run out 
of I/O channels.
Extra #includes on the Unix simulation
headers
Interact routine using system calls 
lseek
read
write
Demo3
“Call by reference”
C++
• You have been taught C++’s version of call by 
reference
C++ code
• For call by reference, the code generated by the 
C++ compiler 
– for the function call pushes the addresses of the 
variables ‘a’ and ‘b’ onto the stack 
– The code generated for the function knows that the 
reference arguments double& arg1, and double& arg2 
are pointers
• Code for temp = arg1; is really something like 
– mov arg1,r0
– mov (r0), temp
• It de‐references the pointers to get at the data value
In C, you make these details explicit!
• Pass by reference, C style
nabg 21
C style pass by reference
• You
– Define the function with pointer data types as 
arguments – double* arg1
– Code the function using explicit de‐referencing of 
the pointers when you want to get at the values of 
the arguments
– Use the & (address of operator) to get the 
addresses needed as arguments in the call to the 
function – swap(&a, &b)
It’s very much like the PDP‐11 code isn’t it!
• The C code here is very close to the assembly 
language code that you would have written for the 
PDP‐11!
• Back in ancient times before C became the favoured 
language for systems programming, proponents of 
other (now dead) languages used to deride C as 
“that high level assembly language for the PDP‐11”.
Linking with libraries
Extra libraries
• A basic C installation will have the libraries for stdio, string, stdlib
etc
• But if you want things like images (a library of code that lets you 
generate a picture as a png file), you must add extra libraries
– You will typically have to use Google a bit to identify appropriate libraries
– You install these libraries using applications like the cygwin setup exe, or 
the synaptic package manager on Ubuntu, or apt‐get install
• A library consists of
– The header file with the declarations of the functions provided and data 
types used etc
– One or both of
• A statically linked library
• A dynamically linked shared library
(The differences will be explained later)
Libraries
• The gcc utility requires
– At compile time: the include header files
– At link time: details of extra libraries that your code uses.
• Your compilation environment will be automatically configured so 
that the most commonly used sets of header files, and the 
corresponding library files, are in known locations
– The compiler and linker will find them automatically
• Less standard libraries? 
– You will have to provide details of where the header files can be found and 
what libraries must be used
– These details go in the project’s “makefile”
• It’s easier when using an IDE like NetBeans or Eclipse – it knows the makefile format and 
will help you enter the details
Where do you find the include files 
and libraries?
• When you install a library package, it will most likely 
end up in one of two places ‐ /usr or /usr/local
– The header file(s) will go in /usr/include or 
/usr/local/include
– The library code will go in /usr/lib or /usr/local/lib
nabg 22
The makefile
• The makefile will need extra lines that direct the 
build process so that 
– The additional header files  can be found by the 
compiler,
– The required libraries are scanned by the linker¶
• This is sometimes problematic!
– The functions in one library may depend on functions in some 
other library
» You need to identify all the libraries required
» You may need to list them in a specific order
• If your code explicitly uses functions in library‐A but not library‐B 
(whose functions are called indirectly through functions in library‐
A) you will probably have to list library‐A first in the link process
¶The task of the linker will be explained in more detail later!
Example –
Using the gd graphics library
• “The GD Graphics Library is a graphics software library by Thomas Boutell and 
others for dynamically manipulating images. Its native programming language is 
ANSI C, but it has interfaces for many other programming languages. It can create 
GIFs, JPEGs, PNGs, and WBMPs. Support for drawing GIFs was dropped in 1999 
when Unisys revoked the royalty‐free license granted to non‐commercial software 
projects for the LZW compression method used by GIFs. When the Unisys patent 
expired worldwide on July 7, 2004, GIF support was subsequently re‐enabled.
• GD originally stood for "GIF Draw". However, since the revoking of the Unisys 
license, it has informally stood for "Graphics Draw".
• GD can create images composed of lines, arcs, text (using program‐selected fonts), 
other images, and multiple colors. Version 2.0 adds support for truecolor images, 
alpha channels, resampling (for smooth resizing of truecolor images), and many 
other features.
• GD supports numerous programming languages including C, PHP, Perl, Python, 
OCaml, Tcl, Lua, Pascal, GNU Octave, REXX, Ruby and Go.”
You will meet GD if you take subjects like CSCI110 or CSCI399 – it’s used in PHP
GD smiley face project
• The GD library is documented at 
http://www.boutell.com/gd/manual2.0.33.html#index
– The library has one header file – gd.h
– For linking, the documentation states that you must link with 
• gd, 
• a library with code for png images, 
• a library for data compression, 
• another image library (for jpeg images), 
• a library for handling fonts (character strings in any generated image), 
• and the maths library
– These libraries must be identified to the linker
NetBeans
• Example is a little NetBeans project
– NetBeans uses a “Properties” dialog that simplifies the task of 
editing the makefile to add include header file collections and 
link libraries
• Right click on the project and select Properties
– There are subsections for the compiler
» Specify things like header file collections
– And for the linker
» List the libraries
• In my install, the gd library header was in /usr/include and the 
libraries in /usr/lib
– Since the headers were in the standard location, I didn’t need to specify 
anything
– I had to list the libraries
NetBeans
Add headers and libraries
Didn’t need to add any extra include directories –
would have had to if library installed in /usr/local or
somewhere else
NetBeans
Add headers and libraries
Needed to specify 6 extra libraries for the linker
nabg 23
Project
• The gd headers must be included
– Right‐click on the include line lets you view the header and 
see the functions that the gd library offers
Code using GD
• Programs using GD have a typical pattern
1. Allocate an image
• An image is a 2d array of 4‐byte integers – alpha, red, green, 
blue
2. Create some colours
3. Use drawing primitives such as gdImageLine()
4. Open a (binary) output file
5. Use a “codec” (coder‐decoder) to write the image array 
in a chosen standard image format – such as gif, jpeg, 
png
Build and run
• The output from the build step shows the make process with 
the linker scanning all those libraries
gcc -c -g -MMD -MP -MF build/Debug/Cygwin_4.x-Windows/main.o.d -o build/Debug/Cygwin_4.x-
Windows/main.o main.c
mkdir -p dist/Debug/Cygwin_4.x-Windows
gcc -o dist/Debug/Cygwin_4.x-Windows/smileyface build/Debug/Cygwin_4.x-Windows/main.o 
/cygdrive/C/cygwin/lib/libgd.dll.a /cygdrive/C/cygwin/lib/libpng.dll.a
/cygdrive/C/cygwin/lib/libjpeg.dll.a /cygdrive/C/cygwin/lib/libz.dll.a
/cygdrive/C/cygwin/lib/libfreetype.dll.a /cygdrive/C/cygwin/lib/libm.a
• It runs
What about all those missing C++ 
features …
Exceptions
Templates
Classes
nabg 24
Exceptions
• I think that these are left to CSCI204
– Idea is you write some code like
try {
// lots of code calling functions –
…
}
catch(sometype varname) {
// deal with anything that went wrong, details
// are in variable named varname of type sometype
…
}
– The point being that the called functions cannot deal with the problem, 
but the code here can
• E.g. 
1. Your called code has to open a named file
2. Deep down the function call chain, the file is found not to exist,
3. The called code cannot do anything about a non‐existent file, so it throws an exception
4. The code here might be able to arrange to ask the user for a different file name and 
then repeat the action with the correctly named file
C
• C has a mechanism to achieve something like this based 
on functions setjmp and longjmp
– You use setjmp to create a special data structure (that basically 
records the current stack pointer), and pass this data structure 
as a reference argument down through the function call 
sequence
– If something goes wrong, you use the longjmp function to 
interpret the data structure and get you back to the point where 
it was created.
• C’s setjmp/longjmp isn’t as tidy as a C++ exception
– It simply smashes the stack, 
C++ should carefully unwind the stack firing any destructors 
appropriate in the functions that are being exited
Templates
• Again, you may not be covering these in the 100‐level 
C++ subjects
• Templates exist to allow you to write “generic” code –
code that can apply to a variety of different data types.
– One of your first examples of templates is likely to be a C++ 
linked list class that can be used to hold data items
• What is the type of a “data item”?
– Well, it could be anything – string, instance of some struct that you’ve 
defined (e.g. struct employeerec), instance of another class.
The linked list part of the code doesn’t care.
• So in C++, you use a “template type”
C++ template class
• There is a complete example at cplusplus.com
Each listnode contains a pointer (to the
next listnode) and a data value.
The template structure allows you to
leave the type of the data value unspecified.
C++ template class
The template List
class, that uses the
template ListNode
class is also given at
Using a C++ template
Code that simply builds a list where the data values are ints
nabg 25
And in C?
• It’s not possible to achieve exactly the same effect –
but you can easily define something like a “list of 
data items” – where the type of a data item is 
flexible.
• In C, you use void*
– void* ‐ pointer to any kind of struct created in the heap
• So you can easily have a C “list class” where each list 
node has a “pointer to list node” link, and a “pointer 
to any data struct” data
A C “list class”???
• Of course you can create “classes” in C
– The first implementation of C++ used a pre‐compiler called Cfront that 
converted the C++ code into standard C that could be compiled with 
existing compilers
• It’s just it’s more work for the programmer – work 
that the C++ compiler automates
– The C++ compiler also applies checks and restrictions that eliminate 
some of the errors that can be made by a programmer constructing a 
“class in C”.