ECE 551 Midterm Review

Announcement: This sheet is only helpful for myself, it doesn’t contains anything I think I am good at. Please refer to articles with prefix [RA] for detailed information.

Midterm review notes from All of Programming Chapter 1 - 13

Chapter 0

Everything is a number.
Everything is a number.
Everything is a number.

Abstraction–the separation of interface from implementation.

The interface of something is what it does, while the implementation is how it does.

Chapter 1 Introduction

7 Steps

  1. Work an example Yyurself
  2. Write down what you just did
  3. Generalize your steps
    • replace instance with variables
    • find repetition
  4. Test your algorithm
  5. Translation to Code
  6. Testing your program
  7. Debugging it

Chapter 5


Chapter 8 Pointers

// We can change where p points(e.g., p = &y; is legal if y is an int). However, changing the value in the box that p points at is illegal.
const int *p = &x;

// the value of x cannot be changed, but the pointer p can be changed.
int const *p = &x;

// the pointed value of p can be changed, the pointer is not allowed to change to point other variable.
int *const p = &x;
Can we change? => **p *p p
int **p Yes Yes Yes
const int **p No Yes Yes
int *const *p Yes No Yes
int **const p Yes Yes No
const int *const *p No No Yes
const int **const p No Yes No
int *const *const p Yes No No
const int *const *const p No No No

Chapter 9 Arrays

Use arrays to initialize structs:

point p = {.x = 3, .y = 4};
point myPoints[] = {{.x = 3, .y = 4}};

Chapter 10 Uses of Pointers

in string.h, strcasecmp performs case-insensitive comparision.

string -> int:

#include <stdlib.h>
int atoi(const char *str);

This convention is common, as it allows for one to write loops which iterate over the array without knowing a priori how many elemnts are in the array.

const char * words[] = {"A", "cat", "likes", "sleeping.", NULL};

Chapter 11 Interacting With the User and System

System call is a special type of function call that transfers control from the program into the operating system.

Process Creation

When the command shell wants to run another program, it makes a couple of system calls. First, it makes a call to create a new process(fork). This new process(which is an identical copy of the original, distinguishable only by the return value of the fork system call) then makes another system call(execve) to replace its running program with the requested program. The execve system call takes an argument specifying the file with the binary to run, a second argument specifying the values to pass the new programm as argv, and a third argument specifying the values to pass for envp.

Read Mode

Mode Read and/or write Does not exist Truncate Position
r read only fails no beginning
r+ read/write fails no beginning
w write only created yes beginning
w+ read/write created yes beginning
a writing created no end
a+ rea/write created no End


Reading files

int ch = 0; // note that it's int here.
while ( (ch = fgetc(f) != EOF) {
// do something
char line[LINE_SIZE];
while(fgets(line, LINE_SIZE, f) != NULL) {
// do something
size_t fread(void *ptr, size_t size, size_t nitems, FILE *stream);

Writing files

size_t fwrite(const void *ptr, size_t size, size_t nitems, FILE* stream);

When transferring data across the network, the program obtains a file descriptor for a socket-the logical abstraction over which data is transferred-via the socket system call.

Another form of interaction that looks like a file is a pipe. A pipe is a one way communication channel between two processes. One process writes data into one “end” of the pipe, and the other process reads from the pipe, obtaining the data that was written in by the first process.

Another way is through device special files. These files are typically found in the /dev directory. For example, /dev/random provides access to the secure pseudo-random number generator provided by the kernel. The /dev/urandom device can be used instead to generate numbers with the same algorithm, but without regard to if there is sufficient entropy available for security-sensitive purposes.