int main(void) { int a, b, c; /* declaration */

Transcription

1 &KDSWHULQ$%& #include <stdio.h> int main(void) { int a, b, c; /* declaration */ float x, y=3.3, z=-7.7; /* declaration with initialization */ printf("input two integers: "); /* function call */ scanf("%d%d", &b, &c); /* function call */ a = b + c; /* assignment stmt */ x = y + z; /* assignment stmt */ return 0; Software 1, TAU

2 Fundamental data types Integral (signed or unsigned) char int Floating point types float double fundamental data types: long form char signed char unsigned char signed short int signed int signed long int usigned short int unsigned int unsigned long int float double long double fundamental data types char signed char unsigned char short int long usigned short unsigned unsigned long float double long double fundamental data types grouped by funcionality integral types: char signed char unsigned char short int long usigned short unsigned unsigned long floating types: float double long double arithmetic types: integral types + floating types Software 1, TAU

3 Constants char int long unsigned float double long double a, x, 0, &, \n 1, 0, -54, L 123l 7766L 0u 23U u 1.2f,.2f, 1.f, F 1.0, l L some character constants and their integer values character: a b c... z integer value: character: A B C... Z integer value: character: integer value: character: & * + integer value: name of character written in C integer value alert \a 7 backslash \\ 92 horizontal tab \t 9 newline \n 10 null character \0 0 Quote \ 39 Software 1, TAU

4 char c = a ; printf("%c", c); /* a is printed */ printf("%d", c); /* 97 is printed */ printf("%c%c%c", c, c+1, c+2); /* abc is printed */ Software 1, TAU some character constants and their integer values character: A B C... Z integer value: char c; int i; for (i= a ; i<= z ; ++i) printf("%c", i); /* abc...z is printed */ for (c=65; c<=90; ++c) printf("%c", c); /* ABC...Z is printed */ for (c= 0 ; c<= 9 ; ++c) printf("%d", c); /* is printed */ Software 1, TAU

5 in stdio.h: #define EOF (-1) #include <stdio.h> int main(void) { int c; while ((c = getchar())!= EOF) { putchar(c); putchar(c); return 0; Software 1, TAU Constants Type char int double Description Single character Special character Hexadecimal code Decimal Octal Hexadecimal int.frac int.frac e[+,-]exp Example g \n \x1a -1, 2, 0, , 010, -020, 080 0xfffe, 0x1000, 0x1, 0x2, 0x4, 0x , e-2, 12.3e-1 5

6 /* Decimal, hexadecimal, octal conversions. */ #include <stdio.h> int main(void) { printf("%d %x %o\n", 19, 19, 19); /* */ printf("%d %x %o\n", 0x1c, 0x1c, 0x1c); /* 28 1c 34 */ printf("%d %x %o\n", 017, 017, 017); /* 15 f 17 */ printf("%d\n", x ); /* 37 */ printf("%x\n", ); /* 1fffff */ printf("%d\n", 0x1FfFFf); /* */ return 0; Software 1, TAU /* Compute the size of some fundamental types. */ #include <stdio.h> int main(void) { printf("the size of some fundamental types is computed.\n\n"); printf(" char:%3d byte \n", sizeof(char)); printf(" short:%3d bytes\n", sizeof(short)); printf(" int:%3d bytes\n", sizeof(int)); printf(" long:%3d bytes\n", sizeof(long)); printf(" unsigned:%3d bytes\n", sizeof(unsigned)); printf(" float:%3d bytes\n", sizeof(float)); printf(" double:%3d bytes\n", sizeof(double)); printf("long double:%3d bytes\n", sizeof(long double)); return 0; Software 1, TAU

7 run on PC Pentium 3": The size of some fundamental types is computed. char: 1 byte short: 2 bytes int: 4 bytes long: 4 bytes unsigned: 4 bytes float: 4 bytes double: 8 bytes long double: 8 bytes Software 1, TAU sizeof(char) = 1 sizeof(short) <= sizeof(int) <= sizeof(long) sizeof(signed) = sizeof(unsigned) = sizeof(int) sizeof(float) <= sizeof(double) <= sizeof(long double) Software 1, TAU

8 #include <stdio.h> int main(void) { int i; unsigned u = UINT_MAX; /* typically */ for (i = 0; i < 5; ++i) printf("%u + %d = %u\n", u, i, u + i); for (i = 0; i < 5; ++i) printf("%u * %d = %u\n", u, i, u * i); return 0; Software 1, TAU run on "scorpio": = = = = = * 0 = * 1 = * 2 = * 3 = * 4 = Software 1, TAU

9 type representation value Binary value unsigned char unsigned char unsigned char unsigned char unsigned char signed char signed char signed char signed char Signed char signed short signed int vvvv vvvv svvv vvvv svvv vvvv vvvv vvvv svvv vvvv vvvv vvvv vvvv vvvv vvvv vvvv signed char sc = -128; /* */ unsigned char uc = 255; /* */ sc = sc - 1; /* = 127 Underflow */ uc = uc + 1; /* = 0 Overflow */ uc = 255; /* */ uc = uc*2; /* = 254 */ 9

10 float representation Decimal: Binary: int.frac*10 exp 2.5*10-27 (=25*10-28) 1.frac*2 exp 1.1* Fixed size, limited accuracy seee eeee sfff ffff ffff ffff ffff ffff double uses 8 bytes #include <stdio.h> int main() { int i; float f; f = 0; for (i = 0; i < 100; ++i) f += 0.01f; printf("%f\n", f); return 0; Output:

11 special float values NaN Not a Number represents an illegal value printf( %f\n, sqrt(-1)); will print -1.#IND00 or NAN INF infinity will print 1.#INF00 Mathematical Functions sqrt() pow() exp() #include <math.h> double!! log() sin() cos() tan() 11

12 #include <math.h> #include <stdio.h> int main(void) { double x; printf("\n%s\n%s\n%s\n\n", "The square root of x and x raised", "to the x power will be computed.", "---"); while (1) { /* do it forever */ printf("input x: "); scanf("%lf", &x); if (x >= 0.0) printf("\n%15s%22.15e\n%15s%22.15e\n%15s%22.15e\n\n", "x = ", x, "sqrt(x) = ", sqrt(x), "pow(x, x) = ", pow(x, x)); else printf("\nsorry, your number must be nonnegative.\n\n"); return 0; Software 1, TAU The square root of x and x raised to the x power will be computed. Input x: 2 x = e+000 sqrt(x) = e+000 pow(x, x) = e+000 Input x: Software 1, TAU

13 The usual arithmetic conversion (promotion) If either operand is of type {long double, the other operand is converted to {long double. Otherwise, if either operand is of type {double, the other operand is converted to {double. Otherwise, if either operand is of type {float, the other operand is converted to {float. Otherwise, the "integral promotions" are performed on both operands, and the following rules are applied: If either operand is of type {unsigned long, the other operand is converted to {unsigned long. Otherwise, if one operand has type {long and the other operand has type {unsigned then one of two possibilities occurs: If a long can represent all the values of an {unsigned, then the operand of type {unsigned is converted to {long. If a long cannot represent all the values of an {unsigned, then both operands are converted to {unsigned long. Otherwise, if either operand is of type {long, the other operand is converted to {long. Otherwise, if either operand is of type {unsigned, the other operand is converted to {unsigned. Otherwise, both operands have type {int. Software 1, TAU char c; short s; int i; unsigned u; unsigned long ul; float f; double d; long double ld; expression type c - s / i int u * i double c + 3 int c double d + s double 2 * i / l long expression type u * 7 - i unsigned f * 7 - i float 7 * s * ul unsigned long ld + c long double u - ul unsigned long u - l *system dependent* Software 1, TAU

14 cast double d = 3.3; int i; unsigned ui; i = (int)d; /* i = 3 */ d = (double)i / 2; /* d = 1.5 */ ui = (unsigned)i; 14