Dangling Pointers

Loading...

Do curso por Duke University

Pointers, Arrays, and Recursion

14 ratings

Duke University

Pointers, Arrays, and Recursion

14 ratings

Curso 3 de 4 em Specialization Introduction to Programming in C

The third course in the specialization Introduction to Programming in C introduces the programming constructs pointers, arrays, and recursion. Pointers provide control and flexibility when programming in C by giving you a way to refer to the location of other data. Arrays provide a way to bundle data by guaranteeing sequences of data are grouped together. Finally, recursive functions—functions that call themselves—provide an alternative to iteration that are very useful for implementing certain algorithms.

Na lição

Arrays

Arrays are sequences of memory of the same type that are guaranteed to be one after another. This is an incredibly useful data format, enabling you to store many things together under one variable name. In this module, you will learn how to use arrays to solve more complex problems and lay the groundwork for more complex data types.

Dangling Pointers3:39

Conheça os instrutores

Andrew D. Hilton
Assistant Professor of the Practice
Electrical and Computer Engineering
Anne Bracy
Senior Lecturer
Computer Science, Cornell University
Genevieve M. Lipp
Adjunct Professor
Electrical and Computer Engineering/Mechanical Engineering
Liz Wendland

In this video we're going to look at executing some broken code,

that results in and uses a dangling pointer.

The first thing that main does is declaring In int * p, and

initialize it with the return value of initArray(2).

We make a box for p, create a frame for initArray, pass the argument 2 for

how large, and move our execution arrow into the function.

The next thing that happened is we declare myArray of size 2.

So we get space for two ints in this frame.

Note that these boxes are not to scale,

howLarge would take up the same amount of memory as each element of myArray.

Each box would take up four bytes if the size of an int were four bytes.

We enter the for loop and i has the value 0.

We initialize the 0 with the element of Array to 0.

Then go through the loop again where i has value 1.

And we initialize myArray at 1, to have a value 1.

Though the Array is fully initialized and we have finished our four loop.

Now we've reach the line return myArray, if you wrote this book and code, you were

probably hoping it would copy the array back into for examples Mains Stack frame.

However, that won't work for a variety of reasons, in main, we've only asked for

space to hold a pointer to an end, and not in some array of arbitrary size.

If we wanted an array in mains frame

we would have had to declare an array there and specify its size.

We will see later in the specialization how we can allocate memory

outside of the stack which would persist across function calls, but

we haven't learned how to do that yet.

So when we return myArray,

the value of the expression myArray is a pointer to the first element of the array.

So the return value that you return to call site location one,

is just a pointer to this location.

So when we return, p is going to be assigned to this pointer.

However in the process of returning from this function, that frame goes away.

So now this pointer points over here, where nothing really exists anymore.

We still assign that value to p and

p points right there in memory at whatever happens to be there.

But there's no box associated with that anymore,

it doesn't belong to a particular variable.

If nothing has changed that memory location, it will still hold zero.

But because that memory location could be reused for something else,

it could change unexpectedly.

So at this point p is dangling, notice how it's pointing at nothing in our diagram.

Dereferencing p is therefore erroneous behavior.

So if we were to for inside this for loop and try to print p and 0,

it'd be whatever value as a memory where p is pointing.

That still may be 0 or it may not be, we don't really know what we're going to get.

If I run this on my computer, I get 0 and then 0 again for the second iteration.

The first time, presumably, you get 0 left over from myArray, but

when it calls printf, printf frame goes right here overwriting this space.

So it's going to destroy the value one, that was in the box previously here.

And this is going to read some values that happened to be in printf's frame,

from the previous call.

Regardless of what happens, this code is broken and

we shouldn't write code like it.

Explore nosso catálogo

Registre-se gratuitamente e obtenha recomendações, atualizações e ofertas personalizadas.

O Coursera proporciona acesso universal à melhor educação do mundo fazendo parcerias com as melhores universidades e organizações para oferecer cursos on-line.

© 2018 Coursera Inc. Todos os direitos reservados.

Baixar na App Store

Baixar no Google Play