introduction2programming theory (PDF)

File information

Author: Ala

This PDF 1.5 document has been generated by Microsoft® Office Word 2007, and has been sent on on 05/11/2017 at 22:12, from IP address 176.221.x.x. The current document download page has been viewed 280 times.
File size: 281.21 KB (18 pages).
Privacy: public file

File preview

2.1. What is the decimal value of the following expressions:
What is the decimal value of the following expressions? While evaluating the
value of the expressions take into account the previously executed
int i, j, k, *p2i;
float fp;

i=0x25; //2*16 + 5 = 37, 0x means that its hexadecimal,
j=025; //2*8 + 5 = 21, 0 means that its octal
k=25; //25
++k; //26
k++; //26

//k is 27 here

k|7; //11011|00111 = 11111b = 31d,
but k doesn’t change
k&011; //11011b & 9d = 11011b & 01001b = 01001b = 9d,
but k doesn’t change
k^0x2; //(xor, exclusive or)11011b ^ 00010b = 11001b = 25d,
but k doesn’t change

fp=10/20; //0
fp=(int) 10.0/20; //0
fp=(float) 10/20; //0.5

k+=2; //29
++(*p2i); //30

i<<3; //37d<<3 = 100101b << 3 = 100101000b = 296d (poof - truth) //BAD->101000b = 40; cut only if > 4bytes
i>>2; //37d>>2 = 100101b >> 2 = 001001b = 9d

2.2. Mark by '*' all instructions with compilation errors.
//No ‘*’, made them red instead.

void syntaxErrors(void)
char *p1="12345";
char a0[]="12345";
char a1[1]="123";
//’char’ so single character in ‘’ or char code, no text
//isn’t enough to say that it
is too short?
char c;
//a0 is address of array
//not an error but it has no effect (just like `0;`)
//p1 is a pointer (an address) and c is a char
//here we pass the address to the char, cool
//compare 1st char from a0[] to c without casting - warning/error
//c is a `char` and ought to be a `char *` in other words
//there is nothing like @ in C
a0=(char*) calloc(1,10);
//assigning a char* to char[]
p1=(char*) calloc(1,10);
//freeing cell of an array on a stack
//trying to free value from stack
return 'a';
// this would work, but the function is defined as void!


2.3. Mark by '*' all instructions that lead to errors or to an
unpredictable program behavior at runtime.
Describe shortly your decision.

char RunTimeErrorsAndProblems(void)
char *p1, c;
char ar[10];
char a1[31]="agsdfsdf";
//p1 points to random memory
if (p1==a1) puts("0");
//Doesn’t compare the strings if that’s what you meant // makes no sense since p1 has no
exact value
if (p1=a1) puts("1");
//Looks weird but no complaints from the compiler // an assignment, not comparison and
still p1 has no value //I think that assingment should be threated as “unpredictable program behavior”, cause it will
always execute.
p1=(char *) calloc(1,10);
if (p1==a1) puts("2");
//Doesn’t compare the strings if that’s what you meant //nothing bad just innocent

comparison//no to jak w końcu? mz jest co najmniej nielogicznie //compare string in a1 with some random shit that is
in just allocated p1! //doesn’t compare the strings but the adresses of the value pointed by the pointer and the adrress
of the first array element
//ar contains garbage // ar has no value
//Out of array bounds
p1=(char*) calloc(1,10);
//Memory leak, previously allocated memory wasn’t freed
//No idea what happens here but itisn’t right //IMO moves pointer -1, then free, bad!
//Cannot free stack variables
//Cannot free stack variables
return (*a1);
//Expecting to return a `char` got `char**` instead


3. Define a structure type that describes a student
The StudentStructure structure type should contain the following data:
• name: a string of 20 characters;
• birthYear: a positive integer value;
• eyeColor: an enumerative type that contains basic colors;
• remarks: a string of characters without any fixed length limit.

Define the following variables:
• stStack - a structure filled with proper data and located on the stack
• stStack - a structure filled with proper data and located on the heap
• stStack - a structure filled with proper data and located in the global memory area
• a10 - an array of 10 such structures of that type
• pA10 - an array of 10 pointers to such structures
• aN – an array of n such structures, n is an integer variable;

typedef enum
} EyeColor; //To be used in the Student struct

typedef struct
char name[20];
unsigned int dateOfBirth;
EyeColor eyeColor;

char* remarks;
} Student;

int main()
//Student on the stack (in the global memory area if outside all the functions)
Student student = { “Joe”, 1993, BLUE, “ ” };
//Student on the stack - alternative way
Student student = { .name=”Joe”, .dateOfBirth=1993, .eyeColor=BLUE, .remarks=”” };
//Student on the heap
Student *student = malloc(sizeof(Student));
strncpy(student->name, “Joe”, sizeof(student->name));
student->dateOfBirth = 1993;
student->eyeColor = BLUE;
student->remarks = strdup(“”);

Student a10[10];
//An array of 10 students,
int i;
for (i=0; i<10; i++)
strncpy(a10[i].name,"Joe", sizeof(; // andrzej always prefers using strncpy

Student *pa10[10];

//An array of 10 pointers to students, fill it with data

for (i=0; i<10; i++)
pa10[i] = malloc(sizeof(Student));
for (i=0;i<10; i++)
pa10[i]=&a10[i]; //what about that? 10 pointers to already filled students ^^

Student *aN = malloc(stud_count*sizeof(Student)); //An array of N students, do it, fill it

for (i=0; i<stud_count; i++)

return 0; }
4. Write a code snippet that:
1. Initializes an integer pointer to an integer variable located in the global memory

int i = 10;

int main(int argc, char* argv)
int *pi = &i;


2. Initializes an integer pointer to an integer variable located on the stack.

int *pi, i = 10;
pi = &i;


3. Initializes an integer pointer to an integer variable located on the heap.

int *pi = malloc(sizeof(int));


4. Defines an enumerative type Color that includes back, white and yellow.

typedef enum {
} Color;
5. Defines a direct recursive function.

int factorial(int x)
return ( x == 1 ? 1 : factorial(x-1)*x ); //if x==1 return factorial(x-1)*x, else return 1; “ternary operator”

6. Defines an indirect recursive function.

void func1()

void func2()

7. Defines a void function with two integer parameters.
The value of the output parameter must be set to the value of the input parameter multiplied by 3

void multiplyByThree(int input, int *output)
*output = input*3;

8. Defines a function that tests if a number is the multiple of 17. If yes then its value
should be 1 and 0 otherwise.

int isMultipleOfSeventeen(int number)
return !(number % 17 == 0);

//f (number % 17 == 0) return 1;
//else return 0;

9. Defines a function that tests if a number is positive and odd. If yes then its value
should be 1 and 0 otherwise.

int isPositiveAndOdd(int number)
return (number > 0 && (number % 2==1) );

//if (number > 0 && (number % 2!=0) ) return 1;
//else return 0;

10. Copies a string of up to 10 characters from a stack variable to the heap.

#include <string.h>
char *string = strndup( stringOnStack, 10 );

5. Code analysis
5.1. Which functions are not properly defined. Justify your

int * p1()
a int i1;
= return(&i1);
i1 is out of scope here even though we have a pointer to where it used to be
in other words, returns a dangling pointer

int * p2()

static int i1;
this is correct since its static, it doesn\t vanisGandhih beyond the scope, so everything is fine

int globInt;
int * p3()
seems legit

int p4() {
int result;
returns garbage (result has no set value), fine otherwise

int *p5() {
return((int*) malloc(sizeof(int)));
doesn’t check if the memory was allocated succesfully, fine otherwise


5.2. What output will produce the function testF?

int f1(int k) {
static int v=2;

int f2(int k) {
int v=2;

int f3(int k) {

int f4(int *k) {

void testF()
int k=2;
//static int v=2; v+=k;
//v+=k; //print k
//int v=2 //v is a local variable, resets every time the function is called
//v+=k; //print k
//k passed by copy (by value) here, doesn’t change in testF function
//returned ++k and printed
//passing by address (by pointer). Incrementing by one
//incrementing once again and printing
0//The output:


//v is static, that’s why it holds it’s value between function calls!

6. Answer following questions
1. What is an algorithm?
Algorithm is an effective method for solving a problem expressed as a finite sequence of well defined steps.
2. What is the native language of a computer?
Machine Code / code that is written to run on a specific processor
3. What is an assembler?
Program which translates from assembly language to machine language.
4. What are the basic differences between an assembler and a high level language?
Assembly language is a low-level language, you need to know the architecture of processor
In high-level languages the operating system will take care of the job of converting the basic program into the machine
code of that particular processor. High-level languages are nearer to human language.
5. Name the basic property of structural programming.
Divide and Conquer (divide long alogorithm into small problems)

Download introduction2programming-theory

introduction2programming-theory.pdf (PDF, 281.21 KB)

Download PDF

Share this file on social networks


Link to this page

Permanent link

Use the permanent link to the download page to share your document on Facebook, Twitter, LinkedIn, or directly with a contact by e-Mail, Messenger, Whatsapp, Line..

Short link

Use the short link to share your document on Twitter or by text message (SMS)


Copy the following HTML code to share your document on a Website or Blog

QR Code to this page

QR Code link to PDF file introduction2programming-theory.pdf

This file has been shared publicly by a user of PDF Archive.
Document ID: 0000693331.
Report illicit content