[DL輪読会] Hybrid computing using a neural network with dynamic external memory
Review on pointers and dynamic objects. Memory Management Static Memory Allocation Memory is...
-
date post
21-Dec-2015 -
Category
Documents
-
view
224 -
download
0
Transcript of Review on pointers and dynamic objects. Memory Management Static Memory Allocation Memory is...
Review on pointers and dynamic objects
Memory Management
Static Memory Allocation Memory is allocated at compiling time
Dynamic Memory Memory is allocated at running time
{ int a[200]; …}
{ int n; cin >> n; a[n]???}
Static vs. Dynamic Objects Static object
Memory is acquired automatically
Memory is returned automatically when object goes out of scope
Dynamic object Memory is acquired by
program with an allocation request
new operation Dynamic objects can
exist beyond the function in which they were allocated
Object memory is returned by a deallocation request
delete operation
Why pointers?Dynamic objects are ‘implemented’ or ‘realized’ by
‘pointers’ which are parts of low-level ‘physical memory’
We don’t like it, but can not avoid it.
Low level languages directly manipulate them
High level languages want to ‘hide’ the pointers (conceptually remove them)
Pointers A pointer is a variable used for storing the address of
a memory cell. We can use the pointer to reference this memory cell
100100…… …… 10241024 ……Memory address: 1024 10032
……1020
Integer a Pointer p
int a;
int* p;
a
Getting an address: address operator &
int a=100; “&a” “the address of a”
100100…… …… …… ……Memory address: 1024
int a = 100;
cout << a; 100
Cout << &a; 1024
……1020
a
Dereferencing Operator * We can access to the value stored in the variable
pointed to by preceding the pointer with the “star” operator (*),
1001008888 …… 10241024 ……Memory address: 1024 10032
……1020
int a = 100;
int* p = &a;
cout << a << endl;
cout << &a << endl;
cout << p << " " << *p << endl;
cout << &p << endl;
a p
*p gives 100
Pointer to pointer …
int a;
int* p;
int** q;
a = 58;
p = &a;
q = &p;
a p q
58
a, *p, and **q are the same object whose value is 58!
But q = &a is illegal!
An asterisk (‘*’) has two usages
In a definition, an asterisk indicates that the object is a pointer.
char* s; // s is of type pointer to char
(char *s; is possible)
In expressions, an asterisk before a pointer indicates the object the pointer pointed to, called dereferencing
int i = 1, j;
int* ptr; // ptr is an int pointer
ptr = &i; // ptr points to i
j = *ptr + 1; // j is assigned 2
cout << *ptr << j << endl; // display "12"
Writing pointer type properly in C++ …
int *a, *b;
a, b are both integer pointers
int* a, b;
a is integer pointer, b is just integer!
typedefine int* IntPt;
IntPt a, b;
typedefine int MyInt;
MyInt k;int k;
int* a;
int* b;?
Recommended!!!
I don’t like this!
Summary * has two usages:
- pointer type definition: int a;
int* p;
- dereferencing: *p is an integer variable if
p = &a;
& has two usages:
- getting address: p = &a;
- reference: int& b a;
b is an alternative name for a
First application in passing parameters (‘swap’ example)
int a=10;
int b=100;
int* p;
int* q;
P = &a;
Q = &b;
p = q;
*p = *q;
?
?
Pointers and References
Reference (implemented as a (const) pointer) is an abstraction,
Not available in C, only in C++.
A pointer can be assigned a new value to point at a different object, but a reference variable always refers to the same object. Assigning a reference variable with a new value actually changes the value of the referred object.
int* p;int m = 10;int& j = m; //validp = &m; //p now points at m
int n = 12;j = n; //the value of m is set to 12. But j still refers to m, not to n.
cout << “value of m = “ << m <<endl; //value of m printed is 12
n = 36;Cout << “value of j = “ << j << endl; //value of j printed is 12
p = &n;
Pointer vs. Reference
A reference variable is different from a pointer
int x=10;
int* ref;
Ref = &x;
int x=10;
int& ref = x;
x
ref
10
int& ref;
10x
ref
Traditional Pointer Usagevoid swap(char* ptr1, char* ptr2){
char temp = *ptr1;*ptr1 = *ptr2;*ptr2 = temp;
}int main() {
char a = 'y';char b = 'n';swap(&a, &b);cout << a << b << endl;return 0;
}
Uese pass-by-value of pointers to ‘change’ variable values
C language does not have ‘call by reference’!
Pass by Reference (better than ‘pointers’)
void swap(char& y, char& z) {char temp = y;y = z;z = temp;
}int main() {
char a = 'y';char b = 'n';swap(a, b);cout << a << b << endl;return 0;
}
y, z are ‘references’, only names, not like ptr1, ptr2 that are variables
Pointers and Arrays
Double faces of an array: int a[10] a is the name of an array, a is also is a constant pointer to its first element
Pointers and Arrays
The name of an array points only to the first element not the whole array.
2
4
8
6
22a[4]
a[0]
a[2]
a[1]
a[3]
a
Result is:
2
2
2
#include <iostream>
Using namespace std;
void main(){
int a[5] = {2,4,6,8,22};
cout << *a << " "
<< a[0] << " "
<< *(&a[0]);
..."
} //main
2
4
8
6
22a[4]
a[0]
a[2]
a[1]
a[3]
Dereference of an array name
This element is called a[0] or *a
To access an array, any pointer to the first element can be used instead of the name of the array.
We could replace *p by *a
#include <iostream>
Using namespace std;
void main(){
int a[5] = {2,4,6,8,22};
int* p = a;
int i = 0;
cout << a[i] << " "
<< *p;
...
}
2
4
8
6
22a[4]
a[0]
a[2]a[1]
a[3]
a p
a
Array name as pointer
2
2
dynamic objects
Static variables (objects) Dynamic variables (objects)
A (direct) named memory location A static part (pointer) + (indirect) nameless memory location
(dynamic part)int a;
a = 20;int* pa;
pa = new int;
*pa = 20;
20a 20pa
static static dynamic
Summary
int* p = new int;
*p = 10;
delete p;
p 10 p 10
int* p = new int[100];
for (i=1;i<100;i++)
p[i] = 10;
delete[] p;
Simple dynamic variable Dynamic array
‘delete p’ is not sufficient
for an array!!!
‘delete’ two actions:
1. Return the object pointed to
2. Point the pointer p to NULL
10 10