Lecture 2026-02-05

Recall:

void inc (int *x){
*x++; //wrong,
// because of precedence ( the postfix always takes precedence over prefix ! ) 

*x = *x + 1;
*x+= 1;
++*x; 
//above three implementations work
}

In C, post fix takes precedence over prefix.

So *x++ means *(x++)

Address is incremented, a value is fetched from the unincremented adder and thrown away. No change to the original var.

Correct:

int inc (int *x){
(*x)++;
}

Now consider:

WRONG because `p.x`, are evaluated first, because of post-fix before prefix. There's TWO reasons why it won't compile. 1. It doesn't make sense to star an integer. 2. Pointers do not have an `x` or `y` field and thus won't even compile

void swap(struct Postn *p){ //its going to take in a POINTER
int temp = *p.x = *p.y;
*p.x = *p.y;
*p.y = temp;
}

Postfix before prefix *p.x means *(p.x)

So, its often a good idea to use parens.

void swap(struct Posn *p){
int temp = (*p).x;
(*p).x = (*p).y;
(*p).y = temp;
}

Make sure its clear when to use an arrow and when to use a dot.

Full access through ptr happens a lot - shortcut:

p -> x

• means (*p).x

More sophisticated user input:

WRONG scanf

scanf("%d", x); 

• Reads x as a decimal integer.

  • Skips leading white step.

• Why is this wrong?

  • scanf is a function - can't modify x

thus, instead:

CORRECT scanf and examples

scanf("%d", &n);

scanf("%d %d", &x, &y);
// skips any amount of whitespace ( including 0 whitespace)

• scanf returns the number of arguments actually read.

  • A lot of options and variety to modify scanf —its very complicated.

Advanced Mutation

• Mutating structures + lists

  • In Scheme

    • can mutate parts of cons of a cons with

      • set-car!

      • set-cdr!

  • In Racket

    • cons fields are immutable

      • cannot be mutated.

• For mutable pairs, Racket has mcons

  • Mutating fields with:

    • mset-car!

    • mset-cdr!

For structs: provide the option #:mutable to allow mutation.

#lang racket


(struct posn ( x y ) )
 (define p (posn 3 4))
  p ; returns #<posn>
  (posn-x p) ; returns 3
  (posn-y p) ; returns 4
  
  
  (struct posn_fixed (x y ) #:transparent )
  (define hello (posn_fixed 5 6))
;  (set-posn_fixed-x! hello 'cheese)
  ; returns error


(struct posn_mutable (x y) #:transparent #:mutable)
(define hi (posn_mutable 3 4 ))

  (set-posn_mutable-x! hi 'ok)
;; works!
  

Semantics:

• 1A - (posn v1 v2) is a value

• NOW- (posn v1 v2) cannot be a simple value if its mutable

  • has to be behave more like a BOX

    • since its a list of elts

How?

• is a struct automatically boxed?

• or is the struct a box?

  • SOL: CHECK IN RACKET

A struct is not automatically boxed, but it does box its contents !

• So we can rewrite (pos v1 v2) as:

  • (define _val1 v1)

  • (define _val2 v2)

  • (posn _val1 _val2)

Recall what underscore means ( won't be expanded ).

(posn-x p)

• where p is (posn _val _val2)

  • find the definition for _val , fetch thev alue

(set-posn-x! p v)

• where p is (posn _val1 _val2)

  • find (define _val1 ....)

  • replace with

    • (define _val1 v)

THINK BOXES!!

(define p1 (posn 3 4 ))
(set-posn-x! p1 5)
=> 
(define _v1 3)
(define _v2 4)
(define p1 (posn _v1 _v2))
(set-posn-x! p1 5)
=> 
(define _v1 3)
(define _v2 4)
(define p1 (posn _v1 _v2))
(set-posn-x! (posn _v1 _v2) 5)
=>
(define v_1 5)
(define v_2 4)
(define p1 (posn _v1 _v2))
(void)

• generalizes to any mutable structs, mcons

Consider:

(define lst` (cons (box 1) empty))
(define lst2 (cons 2 lst1))
(define lst3 (cons 3 lst1))
(set-box! (first (rest lst2)) 4)
(unbox (first (rest lst3)))

• Without underscore variables, this produce 1, but in fact its 4.

lst2 = (cons 2 (cons (box 1 ) empty))
lst3 = (cons 3 (cons (box 1 ) empty))

The two (box 1)s are the same box , can't observe this without the _ vars.

• under our new ruels

(define _val1 1)
lst2 = (cons 2 (cons _val1 empty))
lst3 = (cons 3 (cons _val1 empty))

• Note how the shared item is now reflected and explictly shown !

But its not just the box that is shared.

(deifne lst2 (cons 2 lst1))
(define lst3 (cons 3 lst1))

• The entire tail is shared since lst1 is shared!

  • Not being duplicated but memory and their associated values are being shared.

    • This can be seen since using cons is O(1)

  Both occurrences of lst1 refer to the same lst1.

• So we need to rethink define:

(define x 3)
(set! x 7) x
=> (define x 7) (void) x 
=> 7

Thus, it is NOT just a replacement of all x's with 3, like we initially treated in 1A, otherwise we would have gotten 3.

• So x is not just a value

  • Its something we can mutate

  • an entity we can access

Thus, x must denote a LOCATION and the location contains the value.

• So we don't have just one lookup $\delta$ : var -> value

  • Thus we have two lookups:

    • var -> location

    • location -> value

Thus, set! changes the lcoation -> map, but not the var->location map (nothign changes that )

This is generally true, but only in the last two weeks we will discuss the complexities in racket and for why its not true.

(define ... ) creates a location, fills it with a value.

In C:

Consider

Similar behaviour from discussion above in C instead of Racket

int main(){
int x=1;
int *y = &x;
int *z = y; //this is a pointer not an int 
*y = z;
&z = 3;

print("%d %d %d\n",x, *y, *z);
}

Outputs: 3 3 3

Why?

• y initialized to x's address

• y points to the location where x resides

• z initalized equal to y

  • Therefore, z is also to x address

• *y=2 stores 2 at x's location x==*y==*z==2

• *z=3 stores 3 at x's location x==*y ==*z ==3

• x,*y,*z

  • three different names for the same data

• Called aliasing

  • accessing the same data by different names.

int *z vs int* z;

int *x,y;
//x is a pointer, y is an int.

Thus, to make y also a pointer
int *x, *y;
//Thus,
int* x,y;

//don't do this.
int * x;