Contents
ECE264 Lecture notes, Spring 2011, Prof. Lu
Lecture 1:
Lecture 2:
Lecture (1-21-2011):
Gcc –wall progl.c –o pl
Argument shell
>ls
>-l
>cd
int main(int argc, char* argv[])
}
int abc = 5;
int xyz = 10;
xyz = f1(abc);
if(abc==c)
{
…
}
Return 0;
}
int f1(int abc, char xyz, double stu)
{
int counter;
abc = 10;
f2(abc);
return -1;
}
void f2(int xyz)
{
int abc = -1;
}
Stack vs. Heap!
order of first in last out
counter /////
double 0.5
xyz char ‘a’
abc (main) 5
L1
xyz (int) 10
abc (from f1) 5
frame
abc -1
xyz 10
L2
Regarding maze traversal:
know your location
track your steps go back to last intersection
map your file
priority list
detect exit (confirm there is one)
read maze
Height is unlimited
Max will not exceed 80 for width
(0,0) (0,1)
* * * * *
* *
* E
* * *
* * *
* * * * *
It can start at a intersection
(3,1) (2,3) ASCII
(2,1) (3,3) American
standard
code
for info interchange?
FILE * find = fopen(argv[1], “r”);
if(fhd == 0);
{
/*error*/
}
while(!feof(fhd))
{
int ch = fgetc(fhol);
ch is ‘*’;
‘\n’
}
fclose(fhd)
Lecture (1-26-2011):
- include <stdio.h>
File *fhd;
int numRow=0;
int numCol=0;
int col = 0;
int ch;
if (arg<2)
{
/*error*/
}
fhd = fopen(argv[1]."r");
if(fhd==0)
{
/*error*/
}
while(!feof(fhd))
{
ch = fgetc(fhd);
if(ch=='\n')
{
numRow++;
}
if(num Col<col)
{
numCol = col;
col = 0;
}
col++;
}
printf("width=%d,height=%d\n",numCol,numRow);
gcc prog.c -o prog
We need to know the enviornment and the direction we are going to take:
Need to have a way to remember where we are located:
Pointers:
int x;
x=5
Value ---> 800
address 650y
int *y;
/* y is a pointer to integer*/
y = 'x'; <-- warning message
take x's addr
- y = LHS left hand side take y's value as an adr, modify the value at that addr.
= *y Right hand side (RHS) ---> Means assign
Take y's value as an addr, read from that addr.
- y = 50;
y = &z;
*y = 35; ---> z = 35
Goo mainstreet ---> address
family Johnson ----> value
int a[10];
^-- 3
if(ch=='A')
^-- 65 ascII
memory
one - dimension array
int *a;
a = malloc(numElem *sizeof(int));
^---a's value is the start addr of a piece of memory
a[0] = ____
x = a [0];
.
.
.
free(a); <--- lose 50 points RELEASE THE MEMORY (Memory Leak if not there)
Stack Heap
a 1000
C does not specify sizeof(int)
Portable: Run on different machine
malloc(#elem*sizeof(one elem));
^--- modify the value at that addr
if(a==0)
{
/* malloc fails */
//if malloc fails a is 0
}
you already know the size of the maze.
int array[numRow]; The program does not know when you compile the program!
Lecture (2-9-2011):
- ifndef MAZE_H
#define MAZE_H
#include <stdio.h>
typedef struct
{
int startRow,startCol;
int exitRow, exitCol;
int numRow,numCol;
int** cells;
}Maze;
Maze Maze_construct(char* frame);
void Maze_traverse(Maze m);
void Maze_destruct(Maze m);
- endif
main.c
maze.c
/*maze.c*/
#include "maze.h"
#include <stdio.h>
Maze Maze_contruct(char* fname)
{
FIEL* fMaze;
fMaze = fopen(fname);
if(fMaze ==0)
{
//error
}
while(!feof(fMaze))
{
//stuff
}
}
#include <stdio.h> main.c
#include "maze.h"
int main()
{
Maze m;
if(argc<2)
{
//error
}
m = Mazeconstruct(argv[1]);
Maze_traverse(m)
Maze_destruct(m)
return 0;
}
gcc -c maze.c need malloc
gcc maze.o main.o -o
implicitly link c library
m.cells = malloc (sizeof(char*) * numRow);
for
typedef struct
{
int x;
int y;
int z;
}Vector;
Vector Vector_construct(int a int b int c);
Vector Vector_add(vector v1 vector v2);
Vector Vector_construct(int a, int b, int c)
Pbecor v;;
gcc -c main.c
gcc -c maze.c
gcc main.o maze.o -o ipa1
./ipa1 maze1
current directory
make file for each directory
makeclean
int numLine;
Question:
What does it mean when you return with struct, copy attribute by attribute
Lecture (2-11-2011):
ECE 264 seat = D9
Practice
find the number of ways to partition 10 into the sum of positive and incraesing integers
5 = 1 + 4 | 1 + 1 + 3 wrong
= 2 + 3 | 2 + 1 + 2 wrong
= 5 | 3 + 2 does not count
tail recursion for quiz
f(int **array)
{
}
int ** cells;
cells = malloc()
f(cells);
Maze_traverse(Maze m)
{
if(m.cells[m.currRow][m.currCol]=='E')
{
done!
}
try east
if(m.cells[m.currRow][m.currCol+1]==' ')
{
m.currCol++;
Maze_traverse(m);
}
if(m.cells[m.currRow+1][m.currCol] == ' ')
{
m.currRow++;
Maze_traverse(m);
}
}
if all are not satisfied you backtrack.
tail recursion?
Lecture (2-18-2011):
- include "maze.h"
Maze fileReadin(char* fileName)
{
//read it in as a 2 dimensional array
int ch;
int numVert = 0;
int col = 0;
int lcv = 0;
int mRow = 0;
int mCol = 0;
int numLines = 0;
Maze m; //declare it locally too
//read in file
FILE * fMaze;
fMaze = fopen(fileName, "r");
if(fMaze == 0)
{
printf("There is an Error!");
fclose (fMaze);
}
while(!feof(fMaze))
{
ch = fgetc(fMaze);
col++;
if (ch == '\n')
{
++numLines;
if(numVert < col)
{
numVert = col;
}
col = 0;
}
}
//printf("numLines = %4d numVert = %4d\n", numLines, numVert);
m.numRow = numLines;
m.numCol = numVert;
//-------------------------------------------------DUPLICATE MAtrix
m.cells = malloc(m.numRow * sizeof(int *));
for(lcv = 0; lcv < m.numRow; lcv++)
{
m.cells[lcv] = malloc(m.numCol * sizeof(int));
}
//needed
rewind(fMaze);
for (mRow = 0; mRow < m.numRow; mRow++)
{
for (mCol = 0; mCol < m.numCol; mCol++)
{
m.cells[mRow][mCol] = fgetc(fMaze);
if (m.cells[mRow][mCol] == 'E')
{
m.exitCol = mCol;
m.exitRow = mRow;
//printf("exitCol = %4d exitRow %4d\n",m.exitCol,m.exitRow);
}
if (m.cells[mRow][mCol] == 's')
{
m.startCol = mCol;
m.startRow = mRow;
}
}
}
//close the file
fclose(fMaze);
return m;
}
void Maze_traverse(Maze m,int row,int col, int dir, int* progress, int* found)
{
printf("Move to %d, %d", row, col);
m.currentRow = row;
m.currentCol = col;
if(m.cells[row][col]=='E')
{
*found = TRUE;
return;
}
//termination condition
if((dir!=WEST)&&(canMove(m,row,col,EAST,*found))
{
*progress = FORWARD;
Maze_traverse(m,row,col+1,EAST,progress,found);
revisit(*progress, *found, row, col);
}
if((dir!=NORTH)&&(canMove(m,row,col,SOUTH,*found)
{
*progress = FORWARD;
Maze_traverse(m,row+1,col,SOUTH,progress,found);
revisit(*progress, *found, row, col);
}
if((dir!=EAST)&&(canMove(m,row,col,WEST,*found)
{
*progress = FORWARD;
Maze_traverse(m,row,col-1,WEST,progress,found);
revisit(*progress, *found, row, col);
}
if((dir!=SOUTH)&&(canMove(m,row,col,NORTH,*found)
{
*progress = FORWARD;
Maze_traverse(m,row-1,col,NORTH,progress,found);
revisit(*progress, *found, row, col);
}
*progress = BACKWARD;
}
void Maze_destruct(Maze dTemp)
{
int lcv = 0;
// destruct with struct
for(lcv = 0; lcv < dTemp.numRow; lcv++)
{
free(dTemp.cells[lcv]); // must break down the array in the struct before destroying whole struct.
}
free(dTemp.cells);
}
// #endif
Lecture (2-23-2011):
Review Exam answers
Last problem:
a = 24 b = 4 c = 4
Next project:
Rectangular packing.
No rewind
No fseek
No fopen fclose then another fopen.
typedef struct listnode
{
int value;
struct listnode *next;
}Node;
Node n;
Node *p;
p = Node_construct(5);
Node* Node_construct(int v)
{
Node* a;
a = malloc(sizeof(Node));
a-> value = v;
a-> next = 0;
return a;
}
printf("%d\n", p->value);
