Imperative/procedural Paradigms - expresses computation by fully-controlled/specified manipulation of named data in a step-wise fashion. Foundation of these is the stored program concept. Languages include Fortran, Algol, Pascal, C. Object-oriented - Basically the same as imperative, but related variables and operations on variables are organized into classes called objects. Access privileges of vars and methods (operations) in objects can be defined to reduce (simplify) the interaction among objects. Objects considered the main building blocks of programs, which support features like inheritance, class hierarchy, polymorphism. Smalltalk, C++, Java, C# Functional/applicative - Expresses computation in terms of mathematical functions. Supposed to be easy to understand, simple to use. No concept of memory locations in functional programming languages. Each function takes in a number of values as input (parameters) and produces a single return value. Return values not stored. ML, SML, Lisp/Scheme Logic/declarative - Expresses computation in terms of logic predicates. A logic program is a set of facts, rules, questions. Programs compare a question to each fact and rule in given fact and rulebase. Receive yes/no. Prolog. Program Performance/Features Orthogonality, control structures, data types and data structures, syntax design, support for abstraction, expressiveness, type equivalence, strong vs weak type checking, exception handling, aliasing. Reliability, readability, writeability, reusability, efficiency. features\performance Efficiency Readability/reusability Writeability reliability orthogonality/ simplicity control structures data type/structures syntax design support for abstraction expressiveness strong checking restricted aliasing X X X X X X X X X X X X X X X X X X X X X X
exception handling X Lexical Structure Lexical structure defines the vocabulary of a language. Units include: Identifiers(var names), Keywords (e.g. final, const), Operators (+,-,<, >, AND, NOT), Separators (space, comma), Literals (values that can be assigned to vars of diff types. e.g. integer literals are integer numbers), comments Syntactic Structure Defines the grammar of forming sentences or statements using the lexical units. An imperative language includes: Assignments (int a = 5), Conditional statements (if (blah) {} else {}), Loop statements (for-loop, while-loop) Contextual Structure aka static semantics Defines program semantics before dynamic execution. Includes var declaration, initialization, type checking. Some imperative languages require all vars be initialized when declared at the contextual layer, while others don't. Semantic Structure Describes the meaning of a program, or what the program does during execution. In most imperative languages, there is no formal definition of semantic structure. INformal descriptions normally used to explain what statement does. Semantic structures of functional/logic languages are defined based on whatever math/logic foundation the program is based on. Data type/type checking C uses structural equivalence, C++/Java use name equivalence. In a truly strongly typed language: every name in a program must be associated with a single type known at compile-time, name equivalence is used, and every type inconsistency must be reported. Orthogonality Compositional: If a feature of S1 can be combined with one of set S2, then all S1 can be with S2 Sort 1: If a feature of S1 can be combined with one of S2, THAT feature can be with any in S2 Sort 2: " " " " " ", THAT feature of S2 can be with any S1 Program Processing/Pre-processing Interpretation is direct execution of a program one statement at a time sequentially by interpreter. Compiling compiles code to machine code, and that prog is loaded into an execution environment. Hybrid does both (comp.,>interpret comp'd code). Macros are always pasted in, inline is done when compiler deems it possible
Data in a program consists of several properties Type: what values and operations are allowed Location: where data are stored in memory (heap, stack, or static) Address: an integer associated to a location Name: a name associated to a location Value: what stored in memory Visibility and Scope: who can this see data item and its lifetime forward declaration = prototypes C defines five basic types: Character (char) Integer (int) Floating-point (float) Double precision floating-point (double) Valueless (void) - void pointer, return type of a function C++ adds two types: Boolean (bool) Wide-character (wchar_t) - 16 bits Several of these basic types can be modified using one or more of these modifiers: signed, unsigned, short, long Declaring an Array (static) Correct declarations int a[3] : an integer array of size 3 int a[ ] = {x, y, z} Incorrect declarations int a[2] = {3, 4, 5} int[ ]; STRINGS IN C There is no string type predefined; You have to define your own string; A string is an array of characters; In other words, an array of characters may have two meanings: array, string An array is defined by an initial address and the size: no terminator is needed A string is defined by an initial address and a special character at the end, which is called terminator '\0' This difference occurs when the value is assigned to such variable Two ways to declare: char s1[] = {'h'...'o'} = [h]...[o]. char s2[] = "hello" = [h]...[o][\0] In C, string operations only work with strings, not char arrays REFERENCE VAR PROG #include<iostream> using namespace std; int main(){ int myInt = 10; int& myIntReference = myInt; cout<<"myInt:"<<myInt <<"\t" <<"myIntReference:" <<myIntReference <<endl; myIntReference=60; cout<<"myInt:"<<myInt <<"\t" <<"myIntReference:" <<myIntReference <<endl; cout<<"&myInt:"<<&myInt <<"\t" <<"&myIntReference:" <<&myIntReference<<endl; return 0;} output: myInt:10 myIntReference:10 myInt:60 myIntReference:60 &myInt:0012FF60 &myIntReference:0012FF60 If passing by reference, the ACTUAL VARIABLE will be modified, not the temp in a method. Pointers #include<stdio.h> int main () { int x = 500; int * y = NULL; // initially not pointing to any data variable printf("address of x= %d\t content of y= %d\n",&x ,y); y=&x; // assigning the address of x to y printf("address of x= %d\t content of y= %d\n",&x ,y); *y = 200; // changing the value of x to 200 printf("content of x= %d\t dereferencing y = %d\n",x, *y); y = y + 2; // changing the content of y , y++ *y = 300; // changing the content of the memory location pointed by y printf("content of y= %d\t dereferencing y= %d\t content of x = %d\n",y, *y, x); return 0;}
Program Output: address of x= 1245024 content of y= 0 address of x= 1245024 content of y= 1245024 content of x= 200 dereferencing y = 200 content of y= 1245032 dereferencing y= 300 content of x = 200 Pointers for strings #include<stdio.h> int main () { char *p = "hello", *s = "this is a string"; printf("content of p= %d\t content of s= %d\n", p , s); p = s; printf("content of p= %d\t content of s= %d\n", p , s); printf("%s\n", p); printf("%c\n", *p); printf("%c\n", * (++p)); printf("%c\n", * (++p)); return 0;} Program Output: content of p= 4282408 content of s= 4282388 content of p= 4282388 content of s= 4282388 this is a string t h i Memory Allocation C++ has new and delete commands to allocate and de-allocate memory dynamically C has malloc and free command to allocate and de-allocate memory dynamically C++ example: #include <iostream> using namespace std; int main (){ int i,n; char * buffer; int * intbuff; printf ("Please enter the size of the array? "); cin >> i; buffer = new char[i+1]; // alloc. mem. for char array // buffer = (char*) malloc (i+1); // alloc mem for a char array intbuff = new int[i]; // alloc.mem. for an int array //intbuff = (int *) malloc(i); // allocate memory for an integer array for (n=0; n<i; n++) buffer[n]=rand()%26+'a'; buffer[i]='\0'; for (n=0; n<i; n++) intbuff[n]=n; cout << buffer << "\n"; for (n=0; n<i; n++) cout << intbuff[n] <<"\t"; delete (buffer); // free(buffer); delete (intbuff);//free (intbuff); return 0;}