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):

1. 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):

1. 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);

1. 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