the c++ programming language declarations and constant h.j. kim

The C++ Programming The C++ Programming LanguageLanguage

Declarations and Constant

H.J. Kim

ContentsContents 1. Declarations 2. Declarations 3. Objects and lvalues 4. Lifetime 5. Names 6. Types

Overview Fundametal types Derived types void

Pointers Arrays Structures Type equalency Reference 7. Literals

8. Named constraints const v.s macro Enumerations

9. Fields 10. Unions

DeclarationsDeclarations

Informs the compiler with

1. Name and 2. Type

char ch; // declaration & definition

char* name = "OOPSLA"; // declaration efinition

extern complex sqrt(complex); //declaration

typedef complex point; // declaration

struct user; // declaration

NotesNotes

Declaration + object allocation = definition Exactly one definition for each name, but m

ay many declarations

ScopesScopes

Declaration introduces a name into a scope A declaration of a name in a block can hide

a declaration in an enclosing block or a blobal name cf) hidden global name can be used by using “::''

Function argument naes are considered declared in the outermost block of a function

int x; // global x void f() {

int x; // local x hides global x x = 1; // assign to local x {

int x; // hides first local x x = 2; // assign to second local x ::x = x; // assign to global x

} x = 3; to first local x

}

NotesNotes

Scope rule in C++ A name declared in a function (local name)

from the point of declaration to the end of the block in which its declaration occurs

A name not in a function or in a class (= global name) from the point of declaration to the end of the file in

which its declaration occurs

Objects and LvaluesObjects and Lvalues

Object : a region of storage Lvalue: an expression referring to an

object or a function

int i, j; i = j = 10; // lvalue: i, j

LifetimeLifetime

The time during objects' existence Default lifetime

Objects with local names are created when its

definition is encountered and destroyed when i

ts name goes out of scope

Objects with global names are created and ini

tialized once and live until the program termina

tes

Local objects with the keyword ``static'' live un

til the end of the program f() { static int i; // ..... }

Notice : “i” cannot be accessed outside f()!!

Using the “new” and “delete” operators, user-controlled-lifetime objects can be created

NAMESNAMES

A name consists of a sequence of letters and digits

The first character must be a letter C++ imposes no limit on the number of

characters in a name, but some implementations do

NotesNotes

Names starting with underscore are reserved for special facilities therefore, avoid them as much as possible

hello this_is_a_most_unusually_long_nam

e

_Class

___

Types: OverviewTypes: Overview

Every name in a C++ program has a type associated with it C++ is strongly-typed language

Type determines ...... what operations can be applied to the name

how such operations are interpreted

(cf. operatoroverloading)

The only operators can be applied to typ

e name are:

sizeof : determining the amount of memor

y required to hold an object of the type

new : free-store allocation of objects of th

e type

A type name can be used for explicite ty

pe conversion float f; char* p; ................ long ll = long(p); // convert p to a long int i = int(f); // convert f to an int

Types : Fundamental TypesTypes : Fundamental Types Basic integer types

char short int int long int

enumerate float double long double

Unsigned integers, logical values, bit arrays, etc. can be represented by the keyword ``unsigned''

Signed types can be represented by the keyword ``signed''

In general, when a type is missing in a declaration, ``int'' is assumed

Some guaranteed facts for compiler (implementation)

NotesNotes

1 = sizeof(char) <= sizeof(short) <=sizeof(int) <=

sizeof(long)

sizeof(float) <= sizeof(double) <= sizeof(long d

ouble)

sizeof(I) = sizeof(signed I) = sizeof(unsigned I)

. I = basic integer type

|char| >= 8 , |short| >= 16 , |long| >= 32

Types : Implicit Type ConversionTypes : Implicit Type Conversion

Integral promotion enum Baseballteamtype

{ TWINS, GIANTS, BEARS, LIONS,

TIGERS, EAGLES, DOLPHIN };

Baseballteamtype winner = TWINS;

int i = winner; // integral promotion from enum

// to int, i == 0

Integral conversion

int i = -1; unsigned int j = 10; j = i; // integral conversion from int // to unsigned int i = j; // integral conversion from unsigned // to signed int

NotesNotes

Integral promotion

From char, short int, enum,or int bit-field to int If an int can represent all values of the original ty

pe, the value is converted to int ; otherwise it is converted to unsigned int

Integral conversion

integer =>unsigned integer : the value is the least integer congruent to the

signed integer unsigned integer => signed integer : the value is unchanged if it can be represente

d in the new type ; otherwisethe value is implementation depend

ent

Types : Implicit Type Conversion (cont'd)Types : Implicit Type Conversion (cont'd)

Float and Double float x = 10.0; double y = x; // conversion from float to double

x = y; // conversion from double to float

Floating and Integral int i = 100; float x = i; // conversion int to float i = x; // conversion float to int

NotesNotes

Float and Double float -> double :

the value is unchanged

double -> float : if the value with inrepresentable range, the result ma

y be either the next higher or the next lower representable value;

otherwise the behavior is undefined

Floating and Integral floating -> integral value:

the fractional part is discarded and such conversions are machine dependent

integral -> floating type: loss of precision occurs if an integral value cannot be re

presented exactly as a value of the floating type

etc.

Types : Derived TypesTypes : Derived Types

New types can be derived by using the declaration operators * : pointer & : reference [] : array

(): function

and the structure definition mechanism (eg. struct})

When declaring derived types, note that declaration operators apply to the very next individual name only

int v[10]; int *p; int *v[10], (*p)[10]; int* p, y; // same as int* p; \ int y;

Types : voidTypes : void

Usages : 1. Specify that a function does not return a value

2. The base type for pointers to objects of unkno

wn type void f(); // f does not return a value void* pv; // pointer to object of unknown type

void* malloc(unsigned size); void free(void*);

void f() // C style allocation {

int* pi = (int*)malloc(10*sizeof(int)); char* pc = (char*)malloc(10);

//.................free(pi); free(pc);

}

NotesNotes

A pointer of any type can be assigned to a value of type void* 1.For passing pointers to functions that are not allo

wed to make assumptions about the type of the object

2. For returning untyped objects from functions

Types : PointersTypes : Pointers

For most types T, T* is the type pointer to T

int *pi;char** cpp; // pointer to pointer to charint (*vp)[4]; // pointer to array of 4 intsint (*fp)(char,char*); // pointer to function

// taking (char, char*) arguments // and return an int

NotesNotes

pi

cpp

vp

fp

123

‘a’

function code forint f(char,char*)

123

234456678

Types : ArraysTypes : Arrays For a type T,T[size] is the type “array of size elements of type T” Elements are indexed from 0 to size-1

float v[3]; int a[2][5]; char* vpc[32]; // array of 32 character pointers

The name of an array can also be used as a pointer to its first element int v[5] = {1, 2, 3, 4, 5}; int i = *v // assign v[0] to i

If p is assumed to point to an element of an array: p+1 means the next element of that array p-1 means the previous element of that array

#include <iostream.h>

int v[5] = {1, 2, 3, 4, 5}; int* vp = &(v[2]); cout << *vp; // value of v[2] is printed cout << *(vp+1); // value of v[3] is printed cout << *(vp-1); // value of v[1] is printed

NotesNotes

Only substraction between pointes is allowed.

-> conversion needed

void *p = &aa; void *q = p + 10;

Types : StructuresTypes : Structures A structure is an aggregate of elements of arbitrary

types struct address { char* name;};

The individual member can be accessed using . operator or -> operator address ad; address* adp = &ad;

ad.name = "Jim Dandy"; adp->number = 61;

The name of a type becomes available for use immediately after it has been encountered, and not just after the complete declaration has been seen struct link { link* prev; link* succ; };

NotesNotes

adpad

name

number

adpad

name

number

“Jim Dandy”

ad.name = “Jim Dandy”adp->number = 0

Types : Type EqualencyTypes : Type Equalency Two structure types even when they have the same

members struct s1 {int a;}; struct s2 {int a;};

s1 x; s2 y = x; // error: type mismatch

Structure types are different from fundamental types s1 x; int i = x; // error: type mismatch

A declaration prefixed by the keyword “typedef” declares a new name for the type

typedef char* Pchar; Pchar p1; char* p3 = p1;

Types: ReferenceTypes: Reference For a type T, T& means reference to T A reference must be initialized

int i = 1; int& r = i; // r and i now refer to the same int

For a type T, the initializer for a const T& need not be an lvalue or even of type T

double& dr = 1; // error: lvalue needed const double& cdr = 1; // ok

References can be used for call-by-reference in parameter passing

NotesNotes

1 1

i j,r

‘a’

p ch r,ch

‘a’

char ch; char ch;char *p = &ch; char &r = ch;

*p = ‘a’; r = ‘a’ ;

LiteralsLiterals Integer constants

The type of a decimal constant is int provided it fits into an int; otherwise, it is long

Suffix U : unsigned constant Suffix L : long constant 1234 077 0x3f 3U 3L

Floating-point constants A floating-point constant is of type double Suffix f : floating-point constant of type float 1.23 .23 1. 1.2e10 2.0f

Character constants A character constant is a character enclosed in si

ngle quotes It is possible to represent a character as a one-, two-, or three-digit octal number ( \ followed by oct

al digits), or as a hexadecimal number ( \x followed by hexadecimal digits)

A few characters also have standard names that use backslash \ as an escape character

'a' '\6' '\x5f' '\n' '\t'

NotesNotes String literals

A string literals is a character sequence enclosed in double quotes

The type of string is “array of the appropriate number of characters'' "this is a string"

Zeros 0 is an int Because of standard conversion, 0 can be usedas

a constant of any integer, floating point, or pointer type

Named ConstantsNamed Constants

The keyword const can be added to the declaration of an object to make that object a constant

A constant must be initialized const int model = 90; const int v[] = {1, 2, 3, 4};

When using pointer types: 1.the object pointed to: prefixing a declaration of a

pointer with const const char* pc = "asdf"; // pointer to constant pc[3] = 'a'; // error pc = "ghjk"; // ok 2. the pointer itself: operator *const is used char *const cp = "asdf"; // constant pointer cp[3] = 'a'; // ok p = "ghjk"; // error

NotesNotes

pc

“asdf”

“ghjk”

“asdf”pc

cp

“asdf”

“asdf”

cp

fixed fixed

v.s.

Named Constants : Named Constants : const v.s #defined Macroconst v.s #defined Macro

Macro is processed in preprocessor, not in complier.

Macro statement is not C++ statement => no macro statement needs ‘;’ => two kind of statement in a program cf) embedded SQL in a host program can't show uniform view to the programmer #define MAXLEN 10 const int MAXLEN= 10;

const gives more type information Macro is just text substitution, but const isn't

#define NUM1 2 + 2const int NUM2= 2 + 2;

void main(){

int i = NUM1 * 2; // set i with 6 int j = NUM2 * 2; // set j with 8

// - it's our intention}

Named Constants : EnumeratiNamed Constants : Enumerationsons

Alternative method for naming integer constants enum { ASM, AUTO, BREAK };

Values can also be explicitly given to enumerators enum int16 { sign = 010000, most_significant = 04000, least_significant = 1 };

FieldsFields Bundling several tiny variables together in a struct Saves data space, but the size of the code needed

to manipulate these variables increases

struct sreg { unsigned int enable : 1; unsigned int page : 3; unsigned int : 1; // unused unsigned int mode : 2; unsigned int : 4; // unused unsigned int access : 1; unsigned int length : 1; unsigned int non_resident : 1;

};

UnionsUnions Used when members are not used simultan- eously

struct entry { char* name; char type; union { char* string_value; int int_value; };

};