Upload
others
View
2
Download
0
Embed Size (px)
Citation preview
C programming
Intro to syntax & basic operations
Example 1: simple calculation with I/O
Program, line by line
● Line 1: preprocessor directive; used to incorporate code from existing library – not actually considered part of the C program itself
● Syntax:
#include <name of library>
Program, line by line
● Line 3: heading for main function● Most C instructions take place within functions● Syntax for function definition:
data_type name (argument list)
{
/* instructions */
}
● Program execution begins with first statement in main function
Program, line by line
● Lines 9-11: data declaration statements– set aside memory to hold data items
– line 9 declares a variable that can hold an integer value
– lines 10 & 11 declare integer constants
Program, line by line
● Lines 14-16: input & output statements– printf: function that sends output to the screen
– scanf: function that reads input from the keyboard
– both types of statements are function calls; general syntax for a function call is:
function_name (0 or more arguments)
Program, line by line
● Line 19: return statement– Almost always the last statement in a function (we'll
see a few exceptions along the way)
– Indicates that operation of function should cease
– If associated with a value, indicates the “result” of the function (in the case of main, return 0 just means this program ended normally)
Miscellaneous Elements
● Comments: – Descriptive prose written for the human reader
– Start with /* and end with */
– Can appear anywhere in a program
– Cannot be nested
Miscellaneous Elements
● White space– Blank areas around text
– Can be placed anywhere, or left out, as long as:
● words and string literals aren't broken up and● necessary symbols are in place; examples:
Confusing, but still syntactically correct: Readable, but wrong:
#include <stdio.h>
int main () {printf (“Isn\'t this fun to read?\n”) ;return 0;}
#include <stdio.h>
int main(){ printf(“Isn\'t this much easier?\n”); return 0;}
Basic output● Prereq: include directive for stdio.h
● printf function:
– Takes at least one argument, a string literal (set of characters surrounded by double quotation marks)
– First argument may include:● special characters, like \n (used to indicate an end-of-line
character – action of the Enter key)● format specifiers, like %d (used as placeholder for an
integer value to be specified later)● If format specifier(s) included, additional argument(s)
required:– each argument represented by an expression– must match data type specified (%d means int)
Basic input
● Also requires stdio.h● scanf function:
– Takes a minimum of 2 arguments; IMHO best practice is 2 and only 2!
– First argument: format specifier
– Second argument: address of variable where value is to be stored ('&' character followed by variable name)
Errors● HAPPEN. ALL.THE.
TIME.● Programming has
failure built into the process; learn to be comfortable with it, learn from mistakes
● Or at least don't let it freak you out.
Two Types of Errors● Syntax: violating rules
of the programming language
● Semantic: code that is “grammatically” correct, but doesn't mean what you want it to mean
Above excerpted from “15 Grammar Goofs That Make You Look Silly” by Brian Clark(http://www.copyblogger.com/grammar-goofs/)
Quote below attributed (wrongly!) to Alan Greenspan:“I know you think you understand what you thought I said but I'm not sure you realize that what you heard is not what I meant”
Syntax errors
● Leaving out characters, such as semicolons, brackets, parentheses, quote marks, commas …
● Misspelling words– includes what we normally think of as spelling, but
also
– using uppercase character where lowercase should be, vice versa
● Adding extra characters where they don't belong (brackets or parentheses, often))
Syntax errors
● The good news: compiler catches them
● The bad news: %$#@!!compiler catches them! - & your code won't run until you fix them
Semantic errors
● Code compiles & runs, but produces bad results:– program crashes (nasty, but at least you're alerted
to the problem)
– results are wrong in some more subtle way:● Miscalculation● use of uninitialized variables
Variables, Data Types, & Expressions
● Variable: Named memory location for data storage
● As the name implies, value can be changed● Characteristics:
– unique name (identifier)
– data type (determines amount of memory required & what can be stored there)
● Constant: just like a variable, except can't be changed once initial value given
Declaration● Variable must be declared before it can be used● Syntax:
dataType name; /* or */
dataType name1, name2, name3;
● In C, variable declaration:– sets aside a certain amount of memory (as much as
is needed for specified data type)
– associates value stored there with name
● Caution: memory is not usually empty! Important to initialize variable before you use it in an expression
Initialization
● Means assigning a value to a variable● Typically accomplished via an assignment
statement (though can be done through input)
Assignment
● Value represented by variable changes each time you assign a new expression to it
● Assignment is thus a “destructive” operation: saving a new value destroys the previous saved value (unless you saved it somewhere else)
Example
#include <stdio.h>int main (){ int x; /* could be anything - let's prove it! */ printf("x=%d\n", x); /* OK, now let's assign a value */ x = 4; printf("x=%d\n", x); /* And now let's prove that assignment is NOT a test for equality: */ x = x * 2; printf("x=%d\n", x); return 0;}
Naming in C
● Name (identifier) must start with an alphabetic character (upper or lowercase)
● Can contain more letters, digits, and underscores (and nothing else)
● Cannot use words already part of the language – like int, const, return, void
● Should not use words common in programs – like main, printf, scanf, include
Naming in EGR-167
● Variable (& constant) names should reflect their purpose
– Good examples:
int hourPay;const int HOURS = 40;
– Bad example:
int x;
Naming in EGR-167
● General style principles:– Use ALL UPPERCASE for constant names
– Use mixed case (start letter should be lowercase) for everything else
Data Types in C
● From the computer's point of view, the data type represents:– how much memory is needed by a variable (or
constant)
– how the bits in the memory space should be interpreted
● Data representation applet:
http://math.hws.edu/TMCM/java/DataReps/index.html
● From the programmer's point of view, data type represents what kind of value we can store in a given location
Whole number representation
● Most commonly used type for whole number representation is int (short for integer)
● Uses binary notation to represent number – for most numbers, this is many more digits than required for decimal representation of same number
Whole number representation
● This means that the magnitude of a number is limited by the amount of memory allocated – for a 32-bit integer, the range of possible values is -231 .. 231 – 1
● Consequence: adding 1 to 231 – 1 will give you -231, and subtracting 5 from -231 will give you 231 – 4!
● These phenomena are known as integer overflow and underflow, and can show up as semantic errors in your programs
Whole number representation
● Other data types for integers include short, long, and long long
● Each of these is specified to be either smaller or larger (in number of bits) than int– the more bits you have, the greater the range of
magnitude
– still subject to over/underflow
Whole number representation
● All of the integer types have an unsigned variant– use when only positive numbers are appropriate
– range for typical (32-bit) int is 0 .. 232
– still subject to over/underflow, but won't go negative (will go to 0, in the case of overflow)
Real number representation
● Like integers, real numbers use binary representation, but the bits are interpreted not as whole numbers, but as approximations of real numbers
● Note: the exact same set of bits can be interpreted in radically different ways, depending on the data type!
● Number of bits allocated to each number determines both magnitude (as was seen with integers) and precision of number
Real number representation
● Use a form of scientific notation, or floating-point notation
● Example: the value 254.983 could also be represented as:
2.54983 x 102 or
25498.3 x 10-2
– The former is the standard for scientific notation, and a variation of this is standard in C
– Depending on the circumstances, the number would likely be displayed as either 254.983 or 2.54983e2
Real number representation
● Three data types:– float (short for floating-point number)
– double (short for double-precision floating-point number)
– long double (like a double, but even bigger)
● Most programmers just use double
Floating-point errors
● Although not subject to under/overflow problems like int, real numbers have problems of their own on computers
● Memory space is limited– not all real numbers are finite – consider π for
example, or even 1/3
– numbers with finite representations in decimal form may be infinitely repeating in binary form: this is true of 1/10, for example
● Approximation errors can propagate themselves over several calculations
Error propagation exampleMultiplier Multiplicand 14-bit product Actual product Error1000.001 0.11101000 1110.1001 14.7784 1.46%(16.125) (0.90625) (14.5625)
1110.1001 0.11101000 1101.0011 13.4483 1.94%(14.5625) (13.1885)
1101.0011 0.11101000 1011.1111 12.2380 2.46%(13.1885) (11.9375)
1011.1111 0.11101000 1010.1101 11.1366 2.91%(11.9375) (10.8125)
1010.1101 0.11101000 1001.1100 10.1343 3.79%(10.8125) (9.75)
1001.1100 0.11101000 1000.1101 8.3922 4.44%(9.75) (8.8125)
Characters and Strings
● Character: a single character, represented in memory as an 8-bit number
● Uses ASCII code to represent characters
● Data type char can be used to declare variables to hold these values
● Literal value represented by a single character (or an “escaped” character) in single quotation marks
● Examples:
'a'
'4'
'\n'
Characters and Strings
● String literal: as we have previously seen, a set of characters enclosed in double quotation marks is called a string literal– string: 0 or more characters strung together
– literal: the set of characters IS the value of the string
● C doesn't contain a built-in data type for representing strings but:– can declare a collection of characters called a char array
and store a string in that structure
– many C library functions have built-in support for treating char arrays as strings
Expressions
● Simplest definition: set of symbols that represents a value– every value has a data type
– so every expression has a data type
● Examples:
2 is an int expression
2.0 is a double expression
'2' is a char expression
“2” is a string expression
Expressions
● Literal values (even strings have these, even though there is no string data type per se)
● Variables & constants (represent the value assigned)
● Function calls (sometimes – more on this later)● Compound expressions involving any/all of the
above, in combination with operators
Arithmetic & C
● C has four basic operators for real-number arithmetic, and five for integer arithmetic
● Floating-point operators: *, /, +, -– multiplicative operators take precedence over
additive operators
– no precedence except position/parentheses among operators of same variety
● Integer operators: *, /, %, +, -
Wait – what?
● %?● Form of division – name of operator is modulus● Result of operation is remainder from division of
integers
Integer division & modulus
● To understand this best, forget everything you have learned about division since about the 4th or 5th grade
● Well, don't forget it completely, since floating-point division still works as you'd expect; if you divide a double value by another double value, you'll get a double result
● Extend this thought to integers – if you divide an int by an int, you'll get an int result
Examples
4.0 / 2.0 produces 2.0
4/2 produces 2
5.0 / 2.0 produces 2.5
5/2 produces 2
5%2 produces 1
4%2 produces 0
2%5 produces 2
Mixed-type expressions
● Expressions involving only int or only double values will produce int and double results, respectively
● When both data types are involved in an expression, the result will be of the more precise type – double, in other words
Assigning incompatible values to variables
● C is considered a weakly-typed language– can assign expressions of “wrong” data type to
almost any variable
– if conversion is possible, it will be done (but not always in desirable ways)
● Example:
int n = 8.9; /* n will get 8 */
double nn = n; /* nn will get 8.0 – fractional part gone forever! */
Type casting
● Conversion of a value from one data type to another via assignment (as in the previous example) is called an implicit cast
● Can perform same operation explicitly by placing the desired data type in parentheses in front of the expression you wish to convert
Type casting
● Examples:
int n = (int)(5.0 * 3.5); /* n = 17 */
n = (int)(5.0 * 3.5 + .5); /* n = 18 */
double nn = (double)(2 / 3); /* nn = 0.0 */
nn = (double)2 / 3; /* nn = .666666666667 */