Programming in C - PowerPoint PPT Presentation

About This Presentation

Programming in C


Programming in C Variables, Controls, Functions Different Kinds of Languages Java is an object-oriented programming (OOP) language Problem solving centers on defining ... – PowerPoint PPT presentation

Number of Views:201
Avg rating:3.0/5.0
Slides: 33
Provided by: Denni103


Transcript and Presenter's Notes

Title: Programming in C

Programming in C
  • Variables, Controls, Functions

Different Kinds of Languages
  • Java is an object-oriented programming (OOP)
  • Problem solving centers on defining classes that
    model things like Trucks, Persons, Marbles,
    Strings, and CandyMachine
  • Classes encapsulate data (instance variables) and
    code (methods)
  • C is a procedural language
  • Problem solving centers on defining functions
    that perform a single service like getValidInt(
    ), search( ) and inputPersonData( ).
  • Data is global or passed to functions as
  • No classes

  • Because Java is an OOP language, its libraries
    consist of predefined classes that you can use in
    your applications
  • ArrayList, Scanner, Color, Integer
  • Because C is a procedural language, its library
    consists of predefined functions.
  • Char/string functions (strcpy, strcmp)
  • Math functions (floor, ceil, sin)
  • Input/Output functions (printf, scanf)
  • On-line C/Unix manual -- the man command
  • Description of many C library functions and Unix
  • Usage man ltfunction namegt for C library
    functionsor man ltcommand namegt for Unix commands
  • man printf
  • man dir
  • Search for applicable man pages using the
    apropos command or man -k
  • Learn to use the man command using man man

Hello World
  • In JAVA -- is in a class
  • package hello
  • public class Hello
  • public static void main( String args )
  • System.out.println( Hello World )
  • In C -- Hello.c stands alone
  • include ltstdio.hgt
  • int main( )
  • printf( Hello World\n )
  • return 0

Compiling and Runninga Java Program
unixgt javac -d . .java
unixgt java hello.Hello
Compiling and Running a C Program
unixgt gcc -o hello hello.c
Pre- processor (cpp)
Compiler (cc1)
Assembler (as)
Linker (ld)
Source program (text)
Modified source program (text)
Assembly program (text)
Relocatable object programs (binary)
Executable object program (binary)
unixgt hello
Language Commonality
  • C and Java syntax have much in common
  • Some Data Types
  • Arithmetic operators
  • Logical Operators
  • Control structures
  • Other Operators

Data Types
  • Both languages support the integral types int,
    short, long.
  • Both languages support the floating point types
    double and float
  • Both languages support the character data type
  • Both languages support enumerations - enum
  • C allows the signed (default) and unsigned
    qualifiers for integral types (char, int, short,
  • C does NOT support byte (use char instead)
  • Both languages support arrays using and
    indexing starting with zero (0).

True and False
  • Java supports the bool data type and the keywords
    true and false
  • bool isRed true
  • bool isLarge false
  • C does not support the bool data type. Integer
    variables and expressions are used as instead
  • Any non-zero value is considered true
  • A zero integer value is considered false
  • int isRed 55 / true /
  • int isLarge 0 / false /

Arithmetic Operators
  • Arithmetic operators are the same
  • is used for assignment
  • , -, (plus, minus)
  • , /, (times, divide, mod)
  • , -- (increment, decrement (pre and post))
  • Combinations are the same
  • , -, (plus equal, minus equal)
  • , /, (times equal, divide equal, mod
  • Arithmetic Practice
  • Assignment Practice

Logical Operators
  • Logical operators are the same in C and Java and
    result in a Boolean value.
  • (and)
  • (or)
  • , ! (equal and not equal)
  • lt, lt (less than, less than or equal)
  • gt, gt (greater than, greater than or equal)
  • Boolean Logic Practice

Control Structures
  • Both languages support these control structures
    which function the same way in C and Java
  • for loops
  • But NOT -- for (int i 0 i lt size i)
  • while loops
  • do-while loops
  • switch statements
  • if and if-else statements
  • braces ( , ) are used to begin and end blocks
  • Loop Practice

Other Operators
  • These other operators are the same in C and Java
  • ? (tri-nary hook colon)
  • int larger (x y ? x y)
  • ltlt, gtgt, , , (bit operators)
  • ltlt, gtgt, , ,
  • (brackets for arrays)
  • ( ) parenthesis for functions and type casting
  • much more on these later

  • The define directive can be used to give names
    to important constants in your code. This makes
    your code more readable and more easily
  • The compiler replaces every instance of the
    define name with the text that it represents.
  • Note that there is no terminating semi-colon
  • define MIN_AGE 21
  • ...
  • if (myAge gt MIN_AGE)
  • ...
  • define HELP There is no hope
  • ...
  • printf( s\n, HELP)
  • ...

  • C allows you to define new names for existing
    data types (NOT new data types)
  • This feature can be used to give
    application-specific names to simple types
  • typedef int Temperature
  • typedef long Width
  • Or to give simple names to complex types - more
    on this later
  • Using typedefs makes future changes easier and
    makes the code more relevant to the application

Enumeration Constants
  • C provides the enum as a list of named constant
    integer values (starting a 0 by default)
  • Names in enums must be distinct
  • Often a better alternative to defines
  • Example
  • enum boolean FALSE, TRUE
  • enum months JAN 1, FEB, MAR, APR, MAY, JUN,

  • Comments
  • Both languages support block comments surrounded
    by / and /
  • C DOES NOT support // comment style
  • Declaring variables
  • All variables must be declared at the beginning
    of the block in which they are used
  • Typecasting
  • Both languages allow typecasting - temporarily
    treating a variable as a different type
  • temp (double) degrees / 4
  • Ask me about C99

Functions vs. Methods
  • Java classes include methods which can be called
    from any code with appropriate access (recall
    public methods)
  • C functions are like Java methods, but they dont
    belong to any class. Functions are defined in a
    file and may be either global to your program or
    local to the file in which they are defined.
  • Like Java methods, C functions
  • Have a name
  • Have a return type
  • May have parameters
  • Pass arguments by value
  • Unlike Java methods, a function in C is uniquely
    identified by its name. Therefore, there is no
    concept of method overloading in C as there is in
    Java. There can be only one main( ) function in
    a C application.
  • more on this later

C Function Examples
  • / returns the average of two integer parameters
  • int intAverage( int a, int b )
  • return ( (a b) / 2 )
  • / Simulates dog barking /
  • void bark (int nrTimes)
  • int n
  • for (n 0 n lt nrTimes n)
  • printf(Arf!\n)

Function Prototypes
  • A function prototype defines the functions name,
    return type, and parameters.
  • For example from the previous slide
  • void bark( int n )
  • int average( int a, int b )
  • Before a function may be called, you must provide
    its prototype (or the function definition itself)
    so that the C compiler can verify the function is
    being called correctly.

(note the semi-colon).
  • C functions may be called recursively.
  • Typically a function calls itself
  • A properly written recursive function has the
    following properties
  • A base case - a condition which does NOT make a
    recursive call because a simple solution exists
  • A recursive call with a condition (usually a
    parameter value) that is closer to the base case
    than the condition (parameter value) of the
    current function call
  • Each invocation of the function gets its own set
    of arguments and local variables

Recursion Example
  • / print an integer in decimal
  • K R page 87 (may fail on largest negative
    int) /
  • include ltstdio.hgt
  • void printd( int n )
  • if ( n lt 0 )
  • printf( - )
  • n -n
  • if ( n / 10 ) / (n / 10 ! 0) -- more than 1
    digit /
  • printd( n / 10 ) / recursive call n has 1
    less digit /
  • printf( c, n 10 0) / base case --- 1
    digit /

A Simple C Program
  • / convertTemps.c /
  • include ltstdio.hgt / includes prototype for
    printf, etc /
  • typedef double Temperature
  • / prototype for CtoF /
  • Temperature CtoF( Temperature degreesCelsius)
  • int main( )
  • int temp
  • for (temp 0 temp lt 100 temp 20)
  • printf(2d degrees F 5.2f degrees C\n,
  • temp, CtoF( temp ))
  • return 0
  • / converts temperature in Celsius to Fahrenheit
  • Temperature CtoF(Temperature celsius)

Typical C Program
include ltstdio.hgt typedef double
Temperature Temperature CtoF( Temperature
celcius) int main( ) int temp for
(temp 0 temp lt 100 temp 20)
printf(2d degrees F 5.2f degrees
C\n, temp, CtoF( temp )) return 0 /
converts temperature in Celsius to Fahrenheit
/ Temperature CtoF(Temperature celsius)
Temperature fahrenheit fahrenheit 9.0 /
5.0 celsius 32 return fahrenheit
defines, typedefs, data type definitions, global
variable declarationsfunction prototypes
function definitions
Compiling on Unix
  • Traditionally the name of the C compiler that
    comes with Unix is cc.
  • On the UMBC GL systems, use the GNU compiler
    named gcc.
  • The default name of the executable program that
    is created is a.out
  • unixgt gcc convertTemps.c

Compiler Options
  • -c
  • Compile only (create a .o file), dont link
    (create an executable)
  • gcc -c convertTemps.c
  • -o filename
  • Name the executable filename instead of
    a.outgcc -o project1 convertTemps.c
  • -Wall
  • Report all warningsgcc -Wall convertTemps.c
  • -ansi
  • Force adherence to the C ANSI standardsgcc -ansi
  • Use them together
  • gcc -ansi -Wall -o project1 convertTemps.c

Header Files
  • When a file contains functions to be reused in
    several programs, their prototypes and important
    defines are usually placed into a header ( .h )
    that is then included where needed.
  • Each .h file should be stand alone. That is,
    it should and defines needed by the prototypes
    and include any .h files it needs to avoid
    compiler errors.
  • In this example, the prototype for CtoF() would
    be placed into the file CtoF.h which would then
    be included in convertTemps.c or any other .c
    file that used CtoF( )
  • The code for CtoF( ) would be placed int CtoF.c

  • / CtoF.h /
  • / includes needed by prototypes /
  • / relevant defines /
  • / relevant typedefs /
  • typedef double Temperature
  • / prototype for functions defined in CtoF.c /
  • Temperature CtoF( Temperature celsius )

  • / CtoF.c /
  • / necessary includes, defines /
  • include CtoF.h
  • / converts temp in Celsius to Fahrenheit /
  • Temperature CtoF(Temperature celsius)
  • Temperature fahrenheit
  • fahrenheit 9.0 / 5.0 celsius 32
  • return fahrenheit

convertTemps.c revisited
  • include ltstdio.hgt / note angle brackets /
  • include CtoF.h / note quotes /
  • int main( )
  • int temp
  • for (temp 0 temp lt 100 temp 20)
  • printf(2d degrees F 5.2f degrees C\n,
  • temp, CtoF( temp ))
  • return 0

Compiling and linking
  • When a programs code is separated into multiple
    .c files, we must compile each .c file and then
    combine the resulting .o files to create an
    executable program.
  • The files may be compiled separately and then
    linked together. The -c flag in the first two
    command tells gcc to compile only which results
    in the creation of .o (object) files. In the 3rd
    command, the presence of .o extension tells gcc
    to link the files into an executable
  • gcc -c -Wall -ansi convertTemps.c
  • gcc -c -Wall -ansi CtoF.c
  • gcc -Wall -ansi -o myProgram convertTemps.o
  • Or it can be done all in one step
  • gcc -Wall -ansi -o myProgram convertTemps.c CtoF.c

Java/C Project example
  • Number Theory - a problem about integers
  • http//
Write a Comment
User Comments (0)