# Agenda. Peer Instruction Question 1. Peer Instruction Answer 1. Peer Instruction Question 2 6/22/2011

Size: px
Start display at page:

Transcription

1 CS 61C: Great Ideas in Computer Architecture (Machine Structures) Introduction to C (Part II) Instructors: Randy H. Katz David A. Patterson Spring Lecture #4 1 Machine Interpretation Levels of Representation/Interpretation High Level Language Program (e.g., C) Compiler Assembly Language Program (e.g., MIPS) Assembler Machine Language Program (MIPS) Hardware Architecture Description (e.g., block diagrams) Architecture Implementation temp = v[k]; v[k] = v[k+1]; v[k+1] = temp; lw \$t0, 0(\$2) lw \$t1, 4(\$2) sw \$t1, 0(\$2) sw \$t0, 4(\$2) We are here! Anything can be represented as a number, i.e., data or instructions Logic Circuit Description (Circuit Schematic Diagrams) Spring Lecture #4 2 Peer Instruction Question 1 int *p; *p = 5; printf( %d\n,*p); What is the result from executing this code? a) Prints 5 b) Prints garbage c) Always crashes. d) Almost always crashes. Spring Lecture #4 3 Spring Lecture #4 4 Peer Instruction Answer 1 int *p; *p = 5; printf( %d\n,*p); What is the result from executing this code? a) Prints 5 Uninitialized variables contain garbage, b) Prints garbage p may point to an invalid memory address. c) Always crashes. Trying to write to an invalid address will d) Almost always crashes. crash program (segmentation fault). There s a (very) small chance p may just happen to contain a valid address. Spring Lecture #4 5 Peer Instruction Question 2 void main(); int *p, x=5, y; // init y = *(p = &x) + 1; int z; flip-sign(p); printf("x=%d,y=%d,p=%d\n",x,y,p); flip-sign(int *n)*n = -(*n) How many syntax + logic errors in this C code? #Errors a: 1 b: 2 c: 3 d: 4 e: >4 Spring Lecture #4 6 1

2 Peer Instruction Answer 2 #insert <stdio.h> void main(); int *p, x=5, y; // init y = *(p = &x) + 1; int z; flip-sign(p); printf("x=%d,y=%d,p=%d\n",x,y,*p); flip-sign(int *n)*n = -(*n); How many syntax + logic errors in this C code? #Errors a: 1 b: 2 c: 3 d: 4 e: >4 (6!) Spring Lecture #4 7 Pointers Pointers are used to point to any kind of data (int, char, a struct, etc.) Normally a pointer only points to one type (int, char, a struct, etc.). void * is a type that can point to anything (generic pointer) Use sparingly to help avoid program bugs, and security issues, and other bad things! Spring Lecture #3 8 Pointers and Structures Pointers Summary typedef struct int x; int y; Point; Point p1; Point p2; Point* paddr; /* dot notation */ int h = p1.x; p2.y = p1.y; /* arrow notation these lines are equivalent */ int h = (*paddr).x; int h = paddr->x; Why use pointers? If we want to pass a large struct or array, it s easier / faster / etc. to pass a pointer than the whole thing In general, pointers allow cleaner, more compact code So what are the drawbacks? Pointers are probably the single largest source of bugs in C, so be careful anytime you deal with them Most problematic with dynamic memory management which you will to know by the end of the semester, but not for the projects (there will be a lab later in the semester) Dangling references and memory leaks Spring Lecture #4 9 Spring Lecture #3 10 Arrays (1/5) Declaration: int ar[2]; declares a 2-element integer array: just a block of memory int ar[] = 795, 635; declares and initializes a 2-element integer array Accessing elements: ar[num] returns the num th element Spring Lecture #4 11 Spring Lecture #4 12 2

3 Arrays (2/5) Arrays (3/5) are (almost) identical to pointers char *string and char string[] are nearly identical declarations Differ in subtle ways: incrementing, declaration of filled arrays Key Concept: Array variable is a pointer to the first (0 th ) element Spring Lecture #4 13 Consequences: ar is an array variable, but looks like a pointer ar[0] is the same as *ar ar[2] is the same as *(ar+2) We can use pointer arithmetic to conveniently access arrays An array variable is read-only Cannot say ar = [anything] Declared arrays are only allocated while the scope is valid char *foo() char string[32];...; return string; is incorrect and very very bad Spring Lecture #4 14 Arrays (4/5) Array size n; want to access from 0 to n-1, so you should use counter AND utilize a variable for declaration & incrementation Bad pattern int i, ar[10]; for(i = 0; i < 10; i++)... Better pattern int ARRAY_SIZE = 10 int i, a[array_size]; for(i = 0; i < ARRAY_SIZE; i++)... SINGLE SOURCE OF TRUTH You re utilizing indirection and avoiding maintaining two copies of the number 10 Arrays (5/5) Pitfall: An array in C does not know its own length, and its bounds are not checked! Consequence: We can accidentally access off the end of an array Consequence: We must pass the array and its size to any procedure that is going to manipulate it Segmentation faults and bus errors: These are VERY difficult to find; be careful! (You ll learn how to debug these in lab) Spring Lecture #4 15 Spring Lecture #4 16 Array Summary Array indexing is syntactic sugar for pointers a[i] is treated as *(a+i) E.g., three equivalent ways to zero an array: for (i=0; i < size; i++) a[i] = 0; for (i=0; i < size; i++) *(a+i) = 0; for (p=a; p < a+size; p++) *p = 0; Spring Lecture #4 17 C Strings String in C is just an array of characters char string[] = "abc"; How do you tell how long a string is? Last character is followed by a 0 byte (aka null terminator ) int strlen(char s[]) int n = 0; while (s[n]!= 0) n++; return n; Spring Lecture #4 18 3

4 C String Standard Functions #include <string.h> int strlen(char *string); Compute the length of string int strcmp(char *str1, char *str2); Return 0 if str1 and str2 are identical (how is this different from str1 == str2?) char *strcpy(char *dst, char *src); Copy contents of string src to the memory at dst. Caller must ensure that dst has enough memory to hold the data to be copied Note: dst = src only copies pointers, not string itself Spring Lecture #4 19 Spring Lecture #4 20 Administrivia Give your consent forms to your TA in discussion or lab. HW 1 has been posted get started if you haven t already. Lab 2 has been posted. Spring Lecture #4 21 Spring Lecture #4 22 Arrays as Arguments An array is passed to a function as a pointer The array size is lost! Passing arrays: Really int *array Must explicitly pass the size int foo(int array[], unsigned int size) array[size - 1] int main(void) int a[10], b[5]; foo(a, 10) foo(b, 5) Arrays as Arguments int foo(int array[], unsigned int size) printf( %d\n, sizeof(array)); int main(void) int a[10], b[5]; foo(a, 10) foo(b, 5) printf( %d\n, sizeof(a)); What does this print?... because array is really a pointer (and a pointer is architecture dependent, but likely to be 8 on modern machines!) What does this print? 8 40 Spring Lecture #4 23 Spring Lecture #4 24 4

6 Pointer Arithmetic: Peer Instruction Question How many of the following are invalid? I. pointer + integer II. integer + pointer III. pointer + pointer IV. pointer integer V. integer pointer VI. pointer pointer VII. compare pointer to pointer VIII. compare pointer to integer IX. compare pointer to 0 X. compare pointer to NULL #invalid a: 1 b: 2 c: 3 d: 4 e: 5 Pointer Arithmetic Peer Instruction Answer How many of the following are invalid? I. pointer + integer ptr + 1 II. integer + pointer 1 + ptr III. pointer + pointer ptr + ptr IV. pointer integer ptr - 1 V. integer pointer 1 - ptr VI. pointer pointer ptr - ptr VII. compare pointer to pointer ptr1 == ptr2 VIII. compare pointer to integer ptr == 1 IX. compare pointer to 0 ptr == NULL X. compare pointer to NULL ptr == NULL #invalid a: 1 b: 2 c: 3 d: 4 e: 5 Spring Lecture #4 31 Spring Lecture #4 32 Spring Lecture #4 33 Spring Lecture #4 34 Pointers & Allocation (1/2) After declaring a pointer: int *ptr; ptr doesn t actually point to anything yet (points somewhere, but don t know where). We can either: Make it point to something that already exists, or Allocate room in memory for something new that it will point to Pointers & Allocation (2/2) Option 1: Pointing to something that already exists: int *ptr, var1, var2; var1 = 5; ptr = &var1; var2 = *ptr; var1 and var2 have space implicitly allocated for them ptr? var1? 5 var2? 5 Option 2: Allocate room in memory for new thing to point to. See next lecture. Spring Lecture #4 35 Spring Lecture #4 36 6

7 Arrays (one element past array must be valid) Array size n; want to access from 0 to n-1, but test for exit by comparing to address one element past the array int ar[10], *p, *q, sum = 0;... p = &ar[0]; q = &ar[10]; while (p!= q) /* sum = sum + *p; p = p + 1; */ sum += *p++; Is this legal? C defines that one element past end of array must be a valid address, i.e., will not cause an bus error or address error Pointers and Functions (1/4) Sometimes you want to have a procedure increment a variable What gets printed? void AddOne(int x) x = x + 1; int y = 5; AddOne(y); printf( y = %d\n, y); y = 5 Spring Lecture #4 37 Spring Lecture #4 38 Pointers and Functions (2/4) Solved by passing in a pointer to our subroutine. Now what gets printed? void AddOne(int *p) *p = *p + 1; int y = 5; AddOne(&y); printf( y = %d\n, y); y = 6 Pointers and Functions (3/4) But what if the thing you want changed is a pointer? What gets printed? void IncrementPtr(int p = p + 1; int A[3] = 50, 60, 70; int *q = A; IncrementPtr(q); printf( *q = %d\n, *q); *p) *q = 50 A q Spring Lecture #4 39 Spring Lecture #4 40 Pointers and Functions (4/4) Solution! Pass a pointer to a pointer, declared as **h Now what gets printed? void IncrementPtr(int **h) *h = *h + 1; int A[3] = 50, 60, 70; int *q = A; IncrementPtr(&q); printf( *q = %d\n, *q); *q = 60 A q q Spring Lecture #4 41 Spring Lecture #4 42 7

8 Segmentation Fault vs. Bus Error C Pointer Dangers Bus Error A fatal failure in the execution of a machine language instruction resulting from the processor detecting an anomalous condition on its bus. Such conditions include invalid address alignment (accessing a multi-byte number at an odd address), accessing a physical address that does not correspond to any device, or some other device-specific hardware error. A bus error triggers a processor-level exception which Unix translates into a SIGBUS signal which, if not caught, will terminate the current process. Segmentation Fault An error in which a running Unix program attempts to access memory not allocated to it and terminates with a segmentation violation error and usually a core dump. Unlike Java, C lets you cast a value of any type to any other type without performing any checking int x = 1000; int *p = x; /* invalid */ int *q = (int *) x; /* valid */ First pointer declaration is invalid since the types do not match Second declaration is valid C but is almost certainly wrong Is it ever correct? Spring Lecture #4 43 Spring Lecture #4 44 C String Problems Common mistake is to forget to allocate an extra byte for the null terminator More generally, C requires the programmer to manage memory manually (unlike Java or C++) When creating a long string by concatenating several smaller strings, the programmer must insure there is enough space to store the full string! What if you don t know ahead of time how big your string will be? Buffer overrun security holes! More Common C Errors Difference between assignment and equality a = b is assignment a == b is an equality test One of the most common errors for beginning C programmers! One pattern (when comparing with constant) is to put the var on the right! If you happen to use =, it won t compile! if (3 == a)... Spring Lecture #4 45 Spring Lecture #4 46 And in Conclusion, Pointers and array variables are very similar. Can use pointer or array syntax to index into arrays. Strings are (null terminated) arrays of characters Adding 1 to a pointer moves the pointer by the size of the thing it s pointing to. Pointers are the source of many bugs in C, so handle with care Spring Lecture #4 47 8

### CS61C : Machine Structures

inst.eecs.berkeley.edu/~cs61c CS61C : Machine Structures Lecture #3 C Strings, Arrays, & Malloc 2007-06-27 Scott Beamer, Instructor Sun announces new supercomputer: Sun Constellation CS61C L3 C Pointers

### CS61C Machine Structures. Lecture 4 C Pointers and Arrays. 1/25/2006 John Wawrzynek. www-inst.eecs.berkeley.edu/~cs61c/

CS61C Machine Structures Lecture 4 C Pointers and Arrays 1/25/2006 John Wawrzynek (www.cs.berkeley.edu/~johnw) www-inst.eecs.berkeley.edu/~cs61c/ CS 61C L04 C Pointers (1) Common C Error There is a difference

### CS 61C: Great Ideas in Computer Architecture. C Arrays, Strings, More Pointers

CS 61C: Great Ideas in Computer Architecture C Arrays, Strings, More Pointers Instructor: Justin Hsia 6/20/2012 Summer 2012 Lecture #3 1 Review of Last Lecture C Basics Variables, Functions, Flow Control,

### Number Review. Lecture #3 More C intro, C Strings, Arrays, & Malloc Variables. Clarification about counting down

CS61C L3 C Pointers (1) inst.eecs.berkeley.edu/~cs61c CS61C : Machine Structures Lecture #3 More C intro, C Strings, Arrays, & Malloc Albert Chae Instructor 2008-06-25 Number Review Sign and magnitude

### HW1 due Monday by 9:30am Assignment online, submission details to come

inst.eecs.berkeley.edu/~cs61c CS61CL : Machine Structures Lecture #2 - C Pointers and Arrays Administrivia Buggy Start Lab schedule, lab machines, HW0 due tomorrow in lab 2009-06-24 HW1 due Monday by 9:30am

### More C Pointer Dangers

CS61C L04 Introduction to C (pt 2) (1) inst.eecs.berkeley.edu/~cs61c CS61C : Machine Structures Must-see talk Thu 4-5pm @ Sibley by Turing Award winner Fran Allen: The Challenge of Multi-Cores: Think Sequential,

### Review! * follows a pointer to its value! & gets the address of a variable! Pearce, Summer 2010 UCB! ! int x = 1000; Pearce, Summer 2010 UCB!

CS61C L03 Introduction to C (pt 2) (1)! inst.eecs.berkeley.edu/~cs61c CS61C : Machine Structures Lecture 3 Introduction to C (pt 2) 2010-06-23!!!Instructor Paul Pearce! The typical! development cycle!

### CS61C : Machine Structures

inst.eecs.berkeley.edu/~cs61c CS61C : Machine Structures Lecture 3 Introduction to C (pt 2) 2010-06-23! C help session: Tonight 7:00-9:00pm @ 306 Soda!!!Instructor Paul Pearce! The typical! development

### Instructor: Randy H. Katz hbp://inst.eecs.berkeley.edu/~cs61c/fa13. Fall Lecture #4. Agenda

CS 61C: Great Ideas in Computer Architecture Introduc)on to C, Part II Instructor: Randy H. Katz hbp://inst.eecs.berkeley.edu/~cs61c/fa13 9/10/13 Fall 2013 - - Lecture #4 1 Agenda Pointers and Arrays Administrivia

### CS61C : Machine Structures

inst.eecs.berkeley.edu/~cs61c CS61C : Machine Structures Lecture 4 C Pointers 2004-09-08 Lecturer PSOE Dan Garcia www.cs.berkeley.edu/~ddgarcia Cal flies over Air Force We re ranked 13 th in the US and

### CS 61C: Great Ideas in Computer Architecture C Pointers. Instructors: Vladimir Stojanovic & Nicholas Weaver

CS 61C: Great Ideas in Computer Architecture C Pointers Instructors: Vladimir Stojanovic & Nicholas Weaver http://inst.eecs.berkeley.edu/~cs61c/sp16 1 Agenda Pointers Arrays in C 2 Address vs. Value Consider

### CS 61c: Great Ideas in Computer Architecture

Arrays, Strings, and Some More Pointers June 24, 2014 Review of Last Lecture C Basics Variables, functioss, control flow, types, structs Only 0 and NULL evaluate to false Pointers hold addresses Address

### ECE 15B COMPUTER ORGANIZATION

ECE 15B COMPUTER ORGANIZATION Lecture 13 Strings, Lists & Stacks Announcements HW #3 Due next Friday, May 15 at 5:00 PM in HFH Project #2 Due May 29 at 5:00 PM Project #3 Assigned next Thursday, May 19

### C Arrays, Strings, More Pointers Instructor: Steven Ho

C Arrays, Strings, More Pointers Instructor: Steven Ho Review of Last Lecture C Basics Variables, Functions, Flow Control, Types, and Structs Only 0 and NULL evaluate to FALSE Pointers hold addresses Address

### Reference slides! C Strings! A string in C is just an array of characters.!!!char string[] = "abc";! How do you tell how long a string is?!

CS61C L04 Introduction to C (pt 2) (1)! Reference slides! C Strings! You ARE responsible for the material on these slides (they re just taken from the reading anyway). These were the slides that generated

### Agenda. Address vs. Value Consider memory to be a single huge array. Review. Pointer Syntax. Pointers 9/9/12

Agenda CS 61C: Great Ideas in Computer Architecture Introduc;on to C, Part II Instructors: Krste Asanovic Randy H. Katz hep://inst.eecs.berkeley.edu/~cs61c/f12 Review Pointers Administrivia Arrays Technology

### Reference slides! Garcia, Fall 2011 UCB! CS61C L04 Introduction to C (pt 2) (1)!

Reference slides! You ARE responsible for the material on these slides (they re just taken from the reading anyway). These were the slides that generated the fewest questions in years past (i.e., those

### IT 252 Computer Organization and Architecture Introduction to the C Programming Language

IT 252 Computer Organization and Architecture Introduction to the C Programming Language Chia-Chi Teng Administrivia : You have a question? Tips on getting an answer to your question: Ask a classmate Catch

### CS61C : Machine Structures

inst.eecs.berkeley.edu/~cs61c CS61C : Machine Structures Lecture 4 Introduction to C (pt 2) C Pointers CS61C L03 Introduction to C (pt 2) (1) 2006-09-06 Lecturer SOE Dan Garcia www.cs.berkeley.edu/~ddgarcia

### CS61C : Machine Structures

inst.eecs.berkeley.edu/~cs61c CS61C : Machine Structures Lecture 4 Introduction to C (pt 2) 2014-09-08!!!Senior Lecturer SOE Dan Garcia!!!www.cs.berkeley.edu/~ddgarcia! C most popular! TIOBE programming

### Intro to C: Pointers and Arrays

Lecture 4 Computer Science 61C Spring 2017 January 25th, 2017 Intro to C: Pointers and Arrays 1 Administrivia Teaching Assistants: Let s try that again. Lectures are recorded. Waitlist/Concurrent Enrollment

### Lecture 4: Outline. Arrays. I. Pointers II. III. Pointer arithmetic IV. Strings

Lecture 4: Outline I. Pointers A. Accessing data objects using pointers B. Type casting with pointers C. Difference with Java references D. Pointer pitfalls E. Use case II. Arrays A. Representation in

### Review: C Strings. A string in C is just an array of characters. Lecture #4 C Strings, Arrays, & Malloc

CS61C L4 C Pointers (1) inst.eecs.berkeley.edu/~cs61c CS61C : Machine Structures Lecture #4 C Strings, Arrays, & Malloc Albert Chae Instructor 2008-06-26 Review: C Strings A string in C is just an array

### CS 61C: Great Ideas in Computer Architecture Introduc)on to C, Part II

CS 61C: Great Ideas in Computer Architecture Introduc)on to C, Part II Instructors: Krste Asanovic & Vladimir Stojanovic h>p://inst.eecs.berkeley.edu/~cs61c/sp15 1 Review: Components of a Computer Processor

### Has there been an update to ANSI C? Lecture #3 C Pointers Yes! It s called the C99 or C9x std

CS61C L3 C Pointers (1) inst.eecs.berkeley.edu/~cs61c CS61C : Machine Structures Lecture #3 C Pointers 2005-09-07 There is one handout today at the front and back of the room! Lecturer PSOE, new dad Dan

### Two s Complement Review. Two s Complement Review. Agenda. Agenda 6/21/2011

Two s Complement Review CS 61C: Great Ideas in Computer Architecture (Machine Structures) Introduction to C (Part I) Instructor: Michael Greenbaum http://inst.eecs.berkeley.edu/~cs61c/su11 Suppose we had

### CS61C Machine Structures. Lecture 4 C Structs & Memory Management. 9/5/2007 John Wawrzynek. www-inst.eecs.berkeley.edu/~cs61c/

CS61C Machine Structures Lecture 4 C Structs & Memory Management 9/5/2007 John Wawrzynek (www.cs.berkeley.edu/~johnw) www-inst.eecs.berkeley.edu/~cs61c/ CS 61C L04 C Structs (1) C String Standard Functions

### CS 61C: Great Ideas in Computer Architecture. Lecture 3: Pointers. Bernhard Boser & Randy Katz

CS 61C: Great Ideas in Computer Architecture Lecture 3: Pointers Bernhard Boser & Randy Katz http://inst.eecs.berkeley.edu/~cs61c Agenda Pointers in C Arrays in C This is not on the test Pointer arithmetic

### Agenda. Components of a Computer. Computer Memory Type Name Addr Value. Pointer Type. Pointers. CS 61C: Great Ideas in Computer Architecture

CS 61C: Great Ideas in Computer Architecture Krste Asanović & Randy Katz http://inst.eecs.berkeley.edu/~cs61c And in Conclusion, 2 Processor Control Datapath Components of a Computer PC Registers Arithmetic

### CS 61C: Great Ideas in Computer Architecture Introduc)on to C, Part II. Control. Consider memory to be a single huge array

Review: Components of a Computer CS 61C: Great Ideas in Computer Architecture Introduc)on to C, Part II Processor Control Datapath PC Enable? Read/Write Address Memory Program Bytes Input Instructors:

### CS 61C: Great Ideas in Computer Architecture. Lecture 3: Pointers. Krste Asanović & Randy Katz

CS 61C: Great Ideas in Computer Architecture Lecture 3: Pointers Krste Asanović & Randy Katz http://inst.eecs.berkeley.edu/~cs61c Agenda Pointers in C Arrays in C This is not on the test Pointer arithmetic

### Pointers, Arrays, Memory: AKA the cause of those Segfaults

Computer Science 61C Spring 2018 Wawrzynek and Weaver Pointers, Arrays, Memory: AKA the cause of those F@#)(#@*( Segfaults 1 Agenda Computer Science 61C Spring 2018 Pointers Arrays in C Memory Allocation

### Arrays and Memory Management

Arrays and Memory Management 1 Pointing to Different Size Objects Modern machines are byte-addressable Hardware s memory composed of 8-bit storage cells, each has a unique address A C pointer is just abstracted

### How about them A s!! Go Oaktown!! CS61C - Machine Structures. Lecture 4 C Structures Memory Management Dan Garcia.

How about them A s!! Go Oaktown!! CS61C - Machine Structures Lecture 4 C Structures Memory Management 2002-09-05 Dan Garcia (www.cs.berkeley.edu/~ddgarcia) Dave Patterson (www.cs.berkeley.edu/~patterson)

### CS61C Machine Structures. Lecture 5 C Structs & Memory Mangement. 1/27/2006 John Wawrzynek. www-inst.eecs.berkeley.edu/~cs61c/

CS61C Machine Structures Lecture 5 C Structs & Memory Mangement 1/27/2006 John Wawrzynek (www.cs.berkeley.edu/~johnw) www-inst.eecs.berkeley.edu/~cs61c/ CS 61C L05 C Structs (1) C String Standard Functions

### CS61C : Machine Structures

inst.eecs.berkeley.edu/~cs61c CS61C : Machine Structures Lecture 5 C Memory Management Lecturer PSOE Dan Garcia www.cs.berkeley.edu/~ddgarcia CS 61C L04 C Structures, Memory Management (1) 2004-09-10 Barry

### CS61C : Machine Structures

inst.eecs.berkeley.edu/~cs61c CS61C : Machine Structures Lecture 5 C Memory Management Lecturer PSOE Dan Garcia www.cs.berkeley.edu/~ddgarcia CS61C L05 C Structures, Memory Management (1) 2005-01-28 The

### Arrays and Pointers in C. Alan L. Cox

Arrays and Pointers in C Alan L. Cox alc@rice.edu Objectives Be able to use arrays, pointers, and strings in C programs Be able to explain the representation of these data types at the machine level, including

### CS 102 Computer Architecture. Lecture 2: Introduction to C, Part I. Instructor: Sören Schwertfeger.

CS 102 Computer Architecture Lecture 2: Introduction to C, Part I Instructor: Sören Schwertfeger http://shtech.org/courses/ca/ School of Information Science and Technology SIST ShanghaiTech University

### Lecture 2: C Programm

0 3 E CS 1 Lecture 2: C Programm ing C Programming Procedural thought process No built in object abstractions data separate from methods/functions Low memory overhead compared to Java No overhead of classes

### Lecture 8: Pointer Arithmetic (review) Endianness Functions and pointers

CSE 30: Computer Organization and Systems Programming Lecture 8: Pointer Arithmetic (review) Endianness Functions and pointers Diba Mirza University of California, San Diego 1 Q: Which of the assignment

### CS61C Machine Structures. Lecture 3 Introduction to the C Programming Language. 1/23/2006 John Wawrzynek. www-inst.eecs.berkeley.

CS61C Machine Structures Lecture 3 Introduction to the C Programming Language 1/23/2006 John Wawrzynek (www.cs.berkeley.edu/~johnw) www-inst.eecs.berkeley.edu/~cs61c/ CS 61C L03 Introduction to C (1) Administrivia

### Topics Introduction to Microprocessors

Topics 22440 Introduction to Microprocessors C-Language Review (I) Important: : You will not learn how to code in C in this one lecture! You ll still need some sort of C reference. C Syntax Important Tidits

### Processor. Lecture #2 Number Rep & Intro to C classic components of all computers Control Datapath Memory Input Output

CS61C L2 Number Representation & Introduction to C (1) insteecsberkeleyedu/~cs61c CS61C : Machine Structures Lecture #2 Number Rep & Intro to C Scott Beamer Instructor 2007-06-26 Review Continued rapid

### Pointers (part 1) What are pointers? EECS We have seen pointers before. scanf( %f, &inches );! 25 September 2017

Pointers (part 1) EECS 2031 25 September 2017 1 What are pointers? We have seen pointers before. scanf( %f, &inches );! 2 1 Example char c; c = getchar(); printf( %c, c); char c; char *p; c = getchar();

### CS61C : Machine Structures

inst.eecs.berkeley.edu/~cs61c CS61C : Machine Structures Lecture 2 Introduction to the C Programming Language (pt 1) 2010-06-22!!!Instructor Paul Pearce! There is a handout at the front of the room! Please

### Arrays and Pointers. CSE 2031 Fall November 11, 2013

Arrays and Pointers CSE 2031 Fall 2013 November 11, 2013 1 Arrays l Grouping of data of the same type. l Loops commonly used for manipulation. l Programmers set array sizes explicitly. 2 Arrays: Example

### Arrays and Pointers. Arrays. Arrays: Example. Arrays: Definition and Access. Arrays Stored in Memory. Initialization. EECS 2031 Fall 2014.

Arrays Arrays and Pointers l Grouping of data of the same type. l Loops commonly used for manipulation. l Programmers set array sizes explicitly. EECS 2031 Fall 2014 November 11, 2013 1 2 Arrays: Example

### CS 61c: Great Ideas in Computer Architecture

Introduction to C, Pointers June 24, 2014 Review of Last Lecture Six Great Ideas in Computer Architecture Number Representation Bits can represent anything! n bits can represent up to 2 n things Unsigned,

### Numbers: positional notation. CS61C Machine Structures. Faux Midterm Review Jaein Jeong Cheng Tien Ee. www-inst.eecs.berkeley.

CS 61C Faux Midterm Review (1) CS61C Machine Structures Faux Midterm Review 2002-09-29 Jaein Jeong Cheng Tien Ee www-inst.eecs.berkeley.edu/~cs61c/ Numbers: positional notation Number Base B B symbols

### THE GOOD, BAD AND UGLY ABOUT POINTERS. Problem Solving with Computers-I

THE GOOD, BAD AND UGLY ABOUT POINTERS Problem Solving with Computers-I The good: Pointers pass data around efficiently Pointers and arrays 100 104 108 112 116 ar 20 30 50 80 90 ar is like a pointer to

### Arrays and Pointers (part 1)

Arrays and Pointers (part 1) CSE 2031 Fall 2012 Arrays Grouping of data of the same type. Loops commonly used for manipulation. Programmers set array sizes explicitly. Arrays: Example Syntax type name[size];

### C++ ARRAYS POINTERS POINTER ARITHMETIC. Problem Solving with Computers-I

C++ ARRAYS POINTERS POINTER ARITHMETIC Problem Solving with Computers-I General model of memory Sequence of adjacent cells Each cell has 1-byte stored in it Each cell has an address (memory location) Memory

### CS61C : Machine Structures

Get your clickers ready...! inst.eecs.berkeley.edu/~cs61c CS61C : Machine Structures Lecture 3 Introduction to the C Programming Language (pt 1) 2013-01-28! Hello to Nishant Varma watching from India!!!Senior

### Arrays and Pointers (part 1)

Arrays and Pointers (part 1) CSE 2031 Fall 2010 17 October 2010 1 Arrays Grouping of data of the same type. Loops commonly used for manipulation. Programmers set array sizes explicitly. 2 1 Arrays: Example

### CS61C : Machine Structures

inst.eecs.berkeley.edu/~cs61c CS61C : Machine Structures Lecture 3 Introduction to the C Programming Language (pt 1)!!Lecturer SOE Dan Garcia!!!www.cs.berkeley.edu/~ddgarcia CS61C L03 Introduction to C

### Intermediate Programming, Spring 2017*

600.120 Intermediate Programming, Spring 2017* Misha Kazhdan *Much of the code in these examples is not commented because it would otherwise not fit on the slides. This is bad coding practice in general

### First of all, it is a variable, just like other variables you studied

Pointers: Basics What is a pointer? First of all, it is a variable, just like other variables you studied So it has type, storage etc. Difference: it can only store the address (rather than the value)

### Chapter 16. Pointers and Arrays. Address vs. Value. Another Need for Addresses

Chapter 16 Pointers and Arrays Based on slides McGraw-Hill Additional material 200/2005 Lewis/Martin Pointers and Arrays We've seen examples of both of these in our LC- programs; now we'll see them in

### CS107 Handout 08 Spring 2007 April 9, 2007 The Ins and Outs of C Arrays

CS107 Handout 08 Spring 2007 April 9, 2007 The Ins and Outs of C Arrays C Arrays This handout was written by Nick Parlante and Julie Zelenski. As you recall, a C array is formed by laying out all the elements

### Array Initialization

Array Initialization Array declarations can specify initializations for the elements of the array: int primes[10] = { 2, 3, 5, 7, 11, 13, 17, 19, 23, 29 ; initializes primes[0] to 2, primes[1] to 3, primes[2]

### CS 61C: Great Ideas in Computer Architecture Intro to Assembly Language, MIPS Intro

CS 61C: Great Ideas in Computer Architecture Intro to Assembly Language, MIPS Intro Instructors: Vladimir Stojanovic & Nicholas Weaver http://inst.eecs.berkeley.edu/~cs61c/sp16 1 Machine Interpretation

### CS 31: Intro to Systems Pointers and Memory. Kevin Webb Swarthmore College October 2, 2018

CS 31: Intro to Systems Pointers and Memory Kevin Webb Swarthmore College October 2, 2018 Overview How to reference the location of a variable in memory Where variables are placed in memory How to make

### C: Introduction, Pointers Instructors: Steven Ho, Nick Riasanovsky

C: Introduction, Pointers Instructors: Steven Ho, Nick Riasanovsky Overflow Overflow is when the result of an arithmetic operation can t be represented by the (FINITE) hardware bits i.e. the result is

### CSCI-1200 Data Structures Fall 2017 Lecture 5 Pointers, Arrays, & Pointer Arithmetic

CSCI-1200 Data Structures Fall 2017 Lecture 5 Pointers, Arrays, & Pointer Arithmetic Review from Letctures 3 & 4 C++ class syntax, designing classes, classes vs. structs; Passing comparison functions to

### So far, system calls have had easy syntax. Integer, character string, and structure arguments.

Pointers Page 1 So far, system calls have had easy syntax Wednesday, September 30, 2015 10:45 AM Integer, character string, and structure arguments. But this is not always true. Today, we begin to explore

### A brief introduction to C programming for Java programmers

A brief introduction to C programming for Java programmers Sven Gestegård Robertz September 2017 There are many similarities between Java and C. The syntax in Java is basically

### Lectures 5-6: Introduction to C

Lectures 5-6: Introduction to C Motivation: C is both a high and a low-level language Very useful for systems programming Faster than Java This intro assumes knowledge of Java Focus is on differences Most

### CS 11 C track: lecture 5

CS 11 C track: lecture 5 Last week: pointers This week: Pointer arithmetic Arrays and pointers Dynamic memory allocation The stack and the heap Pointers (from last week) Address: location where data stored

### CS61C : Machine Structures

Get your clickers ready...! inst.eecs.berkeley.edu/~cs61c CS61C : Machine Structures Lecture 3 Introduction to the C Programming Language (pt 1)!!Senior Lecturer SOE Dan Garcia!!!www.cs.berkeley.edu/~ddgarcia

### Introduction to Scientific Computing and Problem Solving

Introduction to Scientific Computing and Problem Solving Lecture #22 Pointers CS4 - Introduction to Scientific Computing and Problem Solving 2010-22.0 Announcements HW8 due tomorrow at 2:30pm What s left:

' 0 3 ' CSE 1 Lecture'3:''' ''''''''''''' C'Programm ing'' C'Programming' 'Procedural'thought'process' 'No'built'in'object'abstractions' data'separate'from'methods/functions' Low'memory'overhead'compared'to'Java'

### CS 61C: Great Ideas in Computer Architecture (Machine Structures) Introduc)on to C (Part I) We are here!

CS 61C: Great Ideas in Computer Architecture (Machine Structures) Introduc)on to C (Part I) Instructors: Randy H. Katz David A. PaGerson hgp://inst.eecs.berkeley.edu/~cs61c/sp11 Summary Spring 2011 - -

### CS61C : Machine Structures

inst.eecs.berkeley.edu/~cs61c CS61C : Machine Structures Lecture #2 Number Rep & Intro to C 2005-08-31 There is one handout today at the front and back of the room! Lecturer PSOE, new dad Dan Garcia www.cs.berkeley.edu/~ddgarcia

### Pointer Basics. Lecture 13 COP 3014 Spring March 28, 2018

Pointer Basics Lecture 13 COP 3014 Spring 2018 March 28, 2018 What is a Pointer? A pointer is a variable that stores a memory address. Pointers are used to store the addresses of other variables or memory

### Processor. Lecture #2 Number Rep & Intro to C classic components of all computers Control Datapath Memory Input Output }

CS61C L2 Number Representation & Introduction to C (1) insteecsberkeleyedu/~cs61c CS61C : Machine Structures Lecture #2 Number Rep & Intro to C 2005-08-31 There is one handout today at the front and back

### CS 61C: Great Ideas in Computer Architecture Intro to Assembly Language, MIPS Intro

CS 61C: Great Ideas in Computer Architecture Intro to Assembly Language, MIPS Intro 1 Levels of Representation/Interpretation Machine Interpretation High Level Language Program (e.g., C) Compiler Assembly

### In Java we have the keyword null, which is the value of an uninitialized reference type

+ More on Pointers + Null pointers In Java we have the keyword null, which is the value of an uninitialized reference type In C we sometimes use NULL, but its just a macro for the integer 0 Pointers are

### Memory, Arrays & Pointers

1 Memory, Arrays & Pointers Memory int main() { char c; int i,j; double x; c i j x 2 Arrays Defines a block of consecutive cells int main() { int i; int a[3]; i a[0] a[1] a[2] Arrays - the [ ] operator

### CMSC 313 COMPUTER ORGANIZATION & ASSEMBLY LANGUAGE PROGRAMMING LECTURE 13, SPRING 2013

CMSC 313 COMPUTER ORGANIZATION & ASSEMBLY LANGUAGE PROGRAMMING LECTURE 13, SPRING 2013 TOPICS TODAY Reminder: MIDTERM EXAM on THURSDAY Pointer Basics Pointers & Arrays Pointers & Strings Pointers & Structs

### CS 61C: Great Ideas in Computer Architecture. Lecture 2: Numbers & C Language. Krste Asanović & Randy Katz

CS 61C: Great Ideas in Computer Architecture Lecture 2: Numbers & C Language Krste Asanović & Randy Katz http://inst.eecs.berkeley.edu/~cs61c Numbers wrap-up This is not on the exam! Break C Primer Administrivia,

### Agenda. CS 61C: Great Ideas in Computer Architecture. Lecture 2: Numbers & C Language 8/29/17. Recap: Binary Number Conversion

CS 61C: Great Ideas in Computer Architecture Lecture 2: Numbers & C Language Krste Asanović & Randy Katz http://inst.eecs.berkeley.edu/~cs61c Numbers wrap-up This is not on the exam! Break C Primer Administrivia,

### Number review... Lecture 3 Introduction to the C Programming Language (pt 1) Has there been an update to ANSI C?

CS61C L03 Introduction to C (pt 1) (1) inst.eecs.berkeley.edu/~cs61c CS61C : Machine Structures Lecture 3 Introduction to the C Programming Language (pt 1) 2008-01-28 Lecturer SOE Dan Garcia Hello to Dev

### ELEC 377 C Programming Tutorial. ELEC Operating Systems

ELE 377 Programming Tutorial Outline! Short Introduction! History & Memory Model of! ommon Errors I have seen over the years! Work through a linked list example on the board! - uses everything I talk about

### CS 61C: Great Ideas in Computer Architecture Introduction to C, Part III

CS 61C: Great Ideas in Computer Architecture Introduction to C, Part III Instructors: John Wawrzynek & Vladimir Stojanovic http://inst.eecs.berkeley.edu/~cs61c/fa15 1 Review, Last Lecture Pointers are

### Sir Syed University of Engineering and Technology. Computer Programming & Problem Solving ( CPPS ) Pointers. Chapter No 7

Computer Programming & Problem Solving ( CPPS ) Chapter No 7 Sir Syed University of Engineering & Technology Computer Engineering Department University Road, Karachi-75300, PAKISTAN Muzammil Ahmad Khan

### CS 61C: Great Ideas in Computer Architecture Lecture 2: Introduction to C, Part I

CS 61C: Great Ideas in Computer Architecture Lecture 2: Introduction to C, Part I Instructors: Vladimir Stojanovic & John Wawrzynek http://inst.eecs.berkeley.edu/~cs61c/ 1 Agenda Compile vs. Interpret

### Why Pointers. Pointers. Pointer Declaration. Two Pointer Operators. What Are Pointers? Memory address POINTERVariable Contents ...

Why Pointers Pointers They provide the means by which functions can modify arguments in the calling function. They support dynamic memory allocation. They provide support for dynamic data structures, such

### Lectures 5-6: Introduction to C

Lectures 5-6: Introduction to C Motivation: C is both a high and a low-level language Very useful for systems programming Faster than Java This intro assumes knowledge of Java Focus is on differences Most

### Lecture #6 Intro MIPS; Load & Store

CS61C L6 Intro MIPS ; Load & Store (1) inst.eecs.berkeley.edu/~cs61c CS61C : Machine Structures Lecture #6 Intro MIPS; Load & Store 2007-7-3 Scott Beamer, Instructor Interesting Research on Social Sites

### ECE 250 / CS 250 Computer Architecture. C to Binary: Memory & Data Representations. Benjamin Lee

ECE 250 / CS 250 Computer Architecture C to Binary: Memory & Data Representations Benjamin Lee Slides based on those from Alvin Lebeck, Daniel Sorin, Andrew Hilton, Amir Roth, Gershon Kedem Administrivia

### EL2310 Scientific Programming

Lecture 11: Structures and Memory (yaseminb@kth.se) Overview Overview Lecture 11: Structures and Memory Structures Continued Memory Allocation Lecture 11: Structures and Memory Structures Continued Memory

### Arrays, Pointers and Memory Management

Arrays, Pointers and Memory Management EECS 2031 Summer 2014 Przemyslaw Pawluk May 20, 2014 Answer to the question from last week strct->field Returns the value of field in the structure pointed to by

### Agenda. Pointer Arithmetic. Pointer Arithmetic pointer + number, pointer number 6/23/2011. Pointer Arithmetic: Peer Instruction Question

Agenda CS 61C: Great Ideas in Computer Architecture (Machine Structures) Memory Management and Malloc Instructors: Michael Greenbaum http://inst.eecs.berkeley.edu/~cs61c/su11 Pointers Review C Memory Management

### Lectures 13 & 14. memory management

Lectures 13 & 14 Linked lists and memory management Courtesy of Prof. Garcia (UCB) CS61C L05 Introduction to C (pt 3) (1) Review Pointers and arrays are virtually same C knows how to increment pointers

### CS 61C: Great Ideas in Computer Architecture. Memory Management and Usage

CS 61C: Great Ideas in Computer Architecture Memory Management and Usage Instructor: Justin Hsia 6/27/2013 Summer 2013 Lecture #4 1 Review of Last Lecture Arrays Traverse using pointer or array syntax

### CSCI-1200 Data Structures Spring 2017 Lecture 5 Pointers, Arrays, Pointer Arithmetic

CSCI-1200 Data Structures Spring 2017 Lecture 5 Pointers, Arrays, Pointer Arithmetic Announcements Submitty iclicker registration is still open. Even if you already registered on the iclicker website,

### C++ for Java Programmers

Basics all Finished! Everything we have covered so far: Lecture 5 Operators Variables Arrays Null Terminated Strings Structs Functions 1 2 45 mins of pure fun Introduction Today: Pointers Pointers Even