SlideShare a Scribd company logo

Multidimensional arrays in C++

Ilio Catallo, profile picture
Ilio Catallo

This document provides an overview of multi-dimensional arrays in C++, detailing their definition, initialization, and accessing methods. It explains the use of type aliases for simplifying array handling and illustrates the differences between arrays of arrays and pointers. Additionally, it covers pointer arithmetic, the implementation of custom functions to work with multi-dimensional arrays, and example code for better understanding.

Technology
1 of 80
1
2
3
4
5
6
7
8
9
10
Most read
11
12
13
Most read
14
15
16
17
Most read
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
Mul$dimensional arrays Ilio Catallo - info@iliocatallo.it
Outline • Arrays of arrays • Arrays of arrays vs. pointers • Pointer arithme4c • Arrays of arrays vs. func4ons • The array of arrays type • Bibliography
Arrays of arrays
How to define an array Arrays are defined by specifying: • The type common to each element • The name of the array • Its size
How to define an array int numbers[4]; • Element type: int • Name: numbers • Size: 4
Array representa+on 0 ... 3 ┌───┬───┬───┬───┐ numbers: │ │ │ │ │ int[4] └───┴───┴───┴───┘
Type aliases C++ supports type aliases, i.e., new names for previously defined types1 using integer = int; integer a = 5; // the same as: int a = 5 1 Star'ng from C++11, type aliases can be introduced by means of the using keyword (in addi'on to the already available typedef keyword)
Type aliases for array types We can introduce type aliases for array types as well. For instance, let us introduce a type alias for the type int[4] using int4 = int[4];
Type aliases for array types We can now define numbers in terms of the type alias int4 using int4 = int[4]; int4 numbers = {1, 7, 13, 10};
Can we now take advantage of our newly-defined alias to define an array of, e.g., 3 elements of type int4?
Array of int4's int4 m[3]; • Element type: ? • Name: ? • Size: ?
Array of int4's int4 m[3]; • Element type: int4 • Name: m • Size: 3
Arrays of arrays Since each element of m is in turn an array, we have effec6vely defined an array of arrays int4 m[3];
Arrays of arrays Specifically, m is an array of 3 elements, where each element is in turn an array of 4 elements int4 m[3];
Array arrays representa+on 0 1 2 ┌─────────────────────┬─────────────────────┬─────────────────────┐ │ ┌───┬───┬───┬───┐ │ ┌───┬───┬───┬───┐ │ ┌───┬───┬───┬───┐ │ m: │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ int4[3] │ └───┴───┴───┴───┘ │ └───┴───┴───┴───┘ │ └───┴───┴───┴───┘ │ └─────────────────────┴─────────────────────┴─────────────────────┘
Ini$alizing an array We know that arrays can be ini1alized using an ini#alizer list int numbers[4] = {1, 7, 13, 10};
Ini$alizing an array In case of numbers, the ini.alizer list is composed of int values // 1 is a int, 7 is a int, ... int numbers[4] = {1, 7, 13, 10};
Ini$alizing an array of arrays In case of m, the ini.alizer list is composed of int4 values using int4 = int[4]; int4 m[3] = { {1, 7, 14, 2}, // {1, 7, 14, 2} is an int4 {8, 16, 12, 10}, // {8, 16, 12, 10} is an int4 {27, 32, 5, 15} }; // {27, 32, 5, 15} is an int4
Accessing inner elements It would be convenient to be able to access inner elements in m using int4 = int[4]; int4 m[3] = { {1, 7, 14, 2}, {8, 16, 12, 10}, {27, 32, 5, 15} };
Accessing inner elements For example, being able to access the element in (2, 1) using int4 = int[4]; int4 m[3] = { {1, 7, 14, 2}, {8, 16, 12, 10}, {27, 32, 5, 15} };
Accessing inner elements In order to do so, it is sufficient to specify the right amount of indices (as many as the number of dimensions) m[2][1]
Accessing inner elements In order to do so, it is sufficient to specify the right amount of indices (as many as the number of dimensions) m[2][1] → {27, 32, 5, 15}[1]
Accessing inner elements In order to do so, it is sufficient to specify the right amount of indices (as many as the number of dimensions) m[2][1] → {27, 32, 5, 15}[1] → 32
Accessing inner elements using int4 = int[4]; int4 m[3] = { {1, 7, 14, 2}, {8, 16, 12, 10}, {27, 32, 5, 15} }; std::cout << m[2][1]; // output: 32
Mul$dimensional arrays Note that m can therefore act as a mul$dimensional array, and, specifically, it can be treated as a matrix
Mul$dimensional arrays Mul$dimensional arrays extend the concept of array to one or more dimensions
Mul$dimensional arrays For common arrays, elements are addressed by specifying one index ┌───┬───┬───┬───┐ │ │ │ │ │ └───┴───┴───┴───┘ ▲ │ i
Mul$dimensional arrays For mul(dimensional arrays, each element is iden(fied by a tuple of indexes (as many as the number of dimensions) ┌───┬───┬───┬───┐ │ │ │ │ │ ├───┼───┼───┼───┤ │ │ │ │ │ ├───┼───┼───┼───┤ │ │ │ │ │◀─── i └───┴───┴───┴───┘ ▲ │ j
Arrays of arrays C++ does not provide proper mul1dimensional arrays. Instead, mul1dimensional arrays are approximated as arrays of arrays
Memory layout Since mul*dim. arrays are approximated as arrays of arrays, it follows that elements are organized in memory as a sequence m[0] m[1] m[2] ◀──────────────▶◀────────────▶◀─────────────▶ ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┐ m: │ │ │ │ │ │ │ │ │ │ │ │ │ int4[3] └───┴───┴───┴───┴───┴───┴───┴───┴───┴───┴───┴───┘
Arrays of arrays vs. pointers
Pointer to first element Assume we want to store the address of the first element of m // {1, 7, 14, 2} is the 1st element int4 m[3] = { {1, 7, 14, 2}, {8, 16, 12, 10}, {27, 32, 5, 15} };
Pointer to first element We start by no,cing that the element type of m is int4 int4 m[3] = { {1, 7, 14, 2}, // {1, 7, 14, 2} is an int4 {8, 16, 12, 10}, // {8, 16, 12, 10} is an int4 {27, 32, 5, 15} }; // {27, 32, 5, 15} is an int4
Pointer to first element Since the element type is equal to int4, a pointer2 to any element in the array has to be of type int4* using int4 = int[4]; int4* first = ... 2 The int4 type alias provides a convenient way to introduce pointers to arrays. Without the intermediate type alias, one would define first to be of type int(*)[4], which is arguably less readable
What to write on the RHS? using int4 = int[4]; int4 m[3] = { {1, 7, 14, 2}, {8, 16, 12, 10}, {27, 32, 5, 15} }; int4* first = ???
What to write on the RHS? using int4 = int[4]; int4 m[3] = { {1, 7, 14, 2}, {8, 16, 12, 10}, {27, 32, 5, 15} }; int4* first = &m[0]; // the address of {1, 7, 14, 2}
Pointer decay As with any array, pointer decay can be used using int4 = int[4]; int4 m[3] = { {1, 7, 14, 2}, {8, 16, 12, 10}, {27, 32, 5, 15} }; // array-to-pointer decay (int4[3] → int4*) int4* first = m;
Pointer decay ┌ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ┐ 0 1 2 │┌─────────────────────┬┼────────────────────┬─────────────────────┐ │ ┌───┬───┬───┬───┐ │ ┌───┬───┬───┬───┐ │ ┌───┬───┬───┬───┐ │ m: ││ │ │ │ │ │ ││ │ │ │ │ │ │ │ │ │ │ │ │ int4[3] │ └───┴───┴───┴───┘ │ └───┴───┴───┴───┘ │ └───┴───┴───┴───┘ │ │└─────────────────────┴┼────────────────────┴─────────────────────┘ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ▲ │ │ │ │ ┌───┐ first:│ │ int4* └───┘
Pointer arithme,c
Pointer arithme,c Given that arrays of arrays are only a par1cular case of arrays, pointer arithme,c can be applied on them without any special considera1on
Pointer arithme,c: addi,on using int4 = int[4]; int4 m[3] = { {1, 7, 14, 2}, {8, 16, 12, 10}, {27, 32, 5, 15} }; int4* first = m; // ptr to {1, 7, 14, 2} int4* second = m + 1; // ptr to {8, 16, 12, 10} int4* third = m + 2; // ptr to {27, 32, 5, 15}
Pointer arithme,c No#ce that pointer arithme#c allows moving between the rows of our 2-dimensional array m int4* first = m; // ptr to {1, 7, 14, 2} int4* second = m + 1; // ptr to {8, 16, 12, 10} int4* third = m + 2; // ptr to {27, 32, 5, 15}
Deriving the indexing operator Let us now try to reduce inner element access to a sequence of pointer arithme,c opera,ons
Deriving the indexing operator To this end, let us consider the following expression: m[2][1]
Deriving the indexing operator By replacing [1] with its defini3on we obtain: m[2][1] → *(m[2] + 1)
Deriving the indexing operator If we do the same for [2] we obtain: m[2][1] → *(m[2] + 1) → *(*(m + 2) + 1)
Indexing operator on arrays of arrays Accessing inner elements of a array of arrays is therefore s2ll defined in terms of pointer arithme,c Given an array of arrays m, and a pair of indexes i and j, the opera3on a[i][j] is implemented as *(*(m + i) + j)
Arrays of arrays vs. func.ons
The sum_int func)on Assume we would like to write a func3on named sum_int, which computes the summa3on of all the elements in a 2-dimensional array
What we know • We can model 2-dimensional arrays as arrays of arrays • Arrays of arrays follow the same rules as normal arrays • We cannot pass arrays by value • The common workaround is to design func>ons that accept a pointer to the 1st element, together with the array size
An interface for sum_int As a first step, let us write sum_int so that it works properly when m is fed as an input using int4 = int[4]; int4 m[3] = { {1, 7, 14, 2}, {8, 16, 12, 10}, {27, 32, 5, 15} };
An interface for sum_int int sum_int(??? first, ??? n);
An interface for sum_int int sum_int(int4* first, std::size_t n);
An interface for sum_int Since we want sum_int to work with m, we impose first to be of type int4 int sum_int(int4* first, std::size_t n);
An interface for sum_int Hence, sum_int can only work with 2-dimensional arrays of exactly 4 columns int sum_int(int4* first, std::size_t n);
An interface for sum_int int sum_int(int4* first, std::size_t n); • The number of rows is determined by the parameter n • The number of columns is fixed by the type of first (int4)
An interface for sum_int If we need to work with 2-dimensional arrays of, e.g., 5 columns, we need to write a new func(on4 int sum_int(int4* first, std::size_t n); int sum_int5(int5* first, std::size_t n); 4 This can be automated by using a func%on template
sum_int → sum_int4 In light of this, let us rename sum_int as sum_int4 int sum_int4(int4* first, std::size_t n);
Implemen'ng sum_int4 int sum_int4(int4* first, std::size_t n) { int sum = 0; for (std::size_t i = 0; i < n; ++i) for (std::size_t j = 0; j < 4; ++j) sum += ??? return sum; }
Implemen'ng sum_int4 int sum_int4(int4* first, std::size_t n) { int sum = 0; for (std::size_t i = 0; i < n; ++i) for (std::size_t j = 0; j < 4; ++j) sum += *(*(first + i) + j); return sum; }
Implemen'ng sum_int4 int sum_int4(int4* first, std::size_t n) { int sum = 0; for (std::size_t i = 0; i < n; ++i) for (std::size_t j = 0; j < 4; ++j) sum += first[i][j]; return sum; }
Invoking sum_int4 int main() { using int4 = int[4]; int4 m[3] = { {1, 7, 14, 2}, {8, 16, 12, 10}, {27, 32, 5, 15} }; int r = sum_int4(???, ???); std::cout << "the elements sum up to " << r; }
Invoking sum_int4 int main() { using int4 = int[4]; int4 m[3] = { {1, 7, 14, 2}, {8, 16, 12, 10}, {27, 32, 5, 15} }; int r = sum_int4(m, 3); std::cout << "the elements sum up to " << r; }
The array of arrays type
The int4 type alias Up to now, we took advantage of the int4 type alias for the defini7on of m using int4 = int[4]; int4 m[3] = { {1, 7, 14, 2}, {8, 16, 12, 10}, {27, 32, 5, 15} };
The int4 type alias We did so in order to stress the true nature of mul1dimensional arrays in C++ using int4 = int[4]; int4 m[3] = { {1, 7, 14, 2}, {8, 16, 12, 10}, {27, 32, 5, 15} };
The data type of m A"er introducing int4, we can say that m is of type int4[3] (i.e., an array of 3 elements of type int4) using int4 = int[4]; int4 m[3] = { {1, 7, 14, 2}, {8, 16, 12, 10}, {27, 32, 5, 15} };
The data type of m However, one could wonder how to express the data type of m without introducing the int4 type alias ??? m[3] = { {1, 7, 14, 2}, {8, 16, 12, 10}, {27, 32, 5, 15} };
The data type of m This amounts to asking what is the result of applying the [3] type constructor on int[4]
Applying [3] on int Construct a type "array of 3 elements of type int" Input type int Type constructor: [3] Output type: int[3]
Applying [3] on int[4] Construct a type "array of 3 elements of type int[4]" Input type: int[4] Type constructor: [3] Output type: int[3][4]
The data type of m Therefore, we conclude that m is of type int[3][4] int m[3][4] = { {1, 7, 14, 2}, {8, 16, 12, 10}, {27, 32, 5, 15} };
Arrays of arrays The common C++ syntax for defining arrays of arrays gives the illusion of working with mul;dimensional arrays int m[3][4] = { {1, 7, 14, 2}, {8, 16, 12, 10}, {27, 32, 5, 15} };
Arrays of arrays However - though the syntax would suggest otherwise - the element type of m is s8ll int[4], not int int m[3][4] = { {1, 7, 14, 2}, {8, 16, 12, 10}, {27, 32, 5, 15} };
The alterna*ve signature As with normal arrays, C++ admits func6on signatures that may appear more natural when dealing with mul6dimensional arrays
The alterna*ve signature Namely, we can change the signature of sum_int4 from this... int sum_int4(int4* first, std::size_t n);
The alterna*ve signature ...to this: int sum_int4(int m[][4], std::size_t n);
The alterna*ve signature int sum_int4(int m[][4], std::size_t n) { int sum = 0; for (std::size_t i = 0; i < n; ++i) for (std::size_t j = 0; j < 4; ++j) sum += m[i][j]; return sum; }
Bibliography
Bibliography • S.B. Lippman et al., C++ Primer (5th Ed.) • B. Stroustrup, The C++ Programming Language (4th Ed.) • StackOverflow FAQ, "How do I use arrays in C++?"

More Related Content

PPTX
Data Structures in Python
Devashish Kumar
 
PPTX
Strings in C language
P M Patil
 
PPTX
Array in c programming
Mazharul Islam
 
PPTX
Two dimensional arrays
Neeru Mittal
 
PPTX
Loops in Python
Arockia Abins
 
PPTX
Python- Regular expression
Megha V
 
PPTX
6-Python-Recursion PPT.pptx
Venkateswara Babu Ravipati
 
PDF
Python strings
Mohammed Sikander
 
Data Structures in Python
Devashish Kumar
 
Strings in C language
P M Patil
 
Array in c programming
Mazharul Islam
 
Two dimensional arrays
Neeru Mittal
 
Loops in Python
Arockia Abins
 
Python- Regular expression
Megha V
 
6-Python-Recursion PPT.pptx
Venkateswara Babu Ravipati
 
Python strings
Mohammed Sikander
 

What's hot (20)

PPTX
Array Introduction One-dimensional array Multidimensional array
imtiazalijoono
 
PPTX
Programming in c Arrays
janani thirupathi
 
PDF
Python list
Prof. Dr. K. Adisesha
 
PPTX
Python Functions
Mohammed Sikander
 
PPTX
Tuple in python
Sharath Ankrajegowda
 
PPTX
Functions in c language
tanmaymodi4
 
PPT
Chapter 11 - Sorting and Searching
Eduardo Bergavera
 
PPT
Basics of pointer, pointer expressions, pointer to pointer and pointer in fun...
Jayanshu Gundaniya
 
PPTX
Deletion from single way linked list and search
Estiak Khan
 
PDF
Python list
Mohammed Sikander
 
PPTX
Arrays
Trupti Agrawal
 
PPTX
Tuple in python
vikram mahendra
 
PPT
Arrays in c
vampugani
 
PPTX
Python-Encapsulation.pptx
Karudaiyar Ganapathy
 
PPTX
Vector class in C++
Jawad Khan
 
PPTX
Arrays In C++
Awais Alam
 
PPTX
Pointers and Structures.pptx
Sharon Manmothe
 
PDF
Python : Functions
Emertxe Information Technologies Pvt Ltd
 
PPTX
Loops in Python.pptx
Guru Nanak Dev University, Amritsar
 
PPT
Introduction to Python
amiable_indian
 
Array Introduction One-dimensional array Multidimensional array
imtiazalijoono
 
Programming in c Arrays
janani thirupathi
 
Python list
Prof. Dr. K. Adisesha
 
Python Functions
Mohammed Sikander
 
Tuple in python
Sharath Ankrajegowda
 
Functions in c language
tanmaymodi4
 
Chapter 11 - Sorting and Searching
Eduardo Bergavera
 
Basics of pointer, pointer expressions, pointer to pointer and pointer in fun...
Jayanshu Gundaniya
 
Deletion from single way linked list and search
Estiak Khan
 
Python list
Mohammed Sikander
 
Arrays
Trupti Agrawal
 
Tuple in python
vikram mahendra
 
Arrays in c
vampugani
 
Python-Encapsulation.pptx
Karudaiyar Ganapathy
 
Vector class in C++
Jawad Khan
 
Arrays In C++
Awais Alam
 
Pointers and Structures.pptx
Sharon Manmothe
 
Python : Functions
Emertxe Information Technologies Pvt Ltd
 
Loops in Python.pptx
Guru Nanak Dev University, Amritsar
 
Introduction to Python
amiable_indian
 
Ad

Viewers also liked (13)

PPT
CBSE Class XI Programming in C++
Pranav Ghildiyal
 
PPTX
Cs1123 3 c++ overview
TAlha MAlik
 
PPT
Overview of c++
geeeeeet
 
PPTX
C++ Overview PPT
Thooyavan Venkatachalam
 
PPTX
Understand Decision structures in c++ (cplusplus)
Muhammad Tahir Bashir
 
PPTX
Overview of c++ language
samt7
 
PPT
Multidimensional array in C
Smit Parikh
 
PPTX
Learn c++ Programming Language
Steve Johnson
 
PDF
Revision notes for exam 2011 computer science with C++
Deepak Singh
 
PPT
Structure of C++ - R.D.Sivakumar
Sivakumar R D .
 
PPTX
Structure in c
baabtra.com - No. 1 supplier of quality freshers
 
PPTX
c++ programming Unit 2 basic structure of a c++ program
AAKASH KUMAR
 
PPS
CS101- Introduction to Computing- Lecture 26
Bilal Ahmed
 
CBSE Class XI Programming in C++
Pranav Ghildiyal
 
Cs1123 3 c++ overview
TAlha MAlik
 
Overview of c++
geeeeeet
 
C++ Overview PPT
Thooyavan Venkatachalam
 
Understand Decision structures in c++ (cplusplus)
Muhammad Tahir Bashir
 
Overview of c++ language
samt7
 
Multidimensional array in C
Smit Parikh
 
Learn c++ Programming Language
Steve Johnson
 
Revision notes for exam 2011 computer science with C++
Deepak Singh
 
Structure of C++ - R.D.Sivakumar
Sivakumar R D .
 
Structure in c
baabtra.com - No. 1 supplier of quality freshers
 
c++ programming Unit 2 basic structure of a c++ program
AAKASH KUMAR
 
CS101- Introduction to Computing- Lecture 26
Bilal Ahmed
 
Ad

Similar to Multidimensional arrays in C++ (20)

PDF
Arrays in C++
Ilio Catallo
 
PPTX
arrays.pptx
HarmanShergill5
 
PPTX
Generative Coding Lecture notes using coding
ssuserff773c
 
PPT
Unit4 Slides
Anurag University Hyderabad
 
PPT
Array
Mayank Saxena
 
PPT
Basics of Data structure using C describing basics concepts
shanthidl1
 
PPTX
Python Datatypes by SujithKumar
Sujith Kumar
 
PPTX
Visual Programing basic lectures 7.pptx
Mrhaider4
 
PPTX
Chap1 array
raksharao
 
PPTX
Chapter 13.pptx
AnisZahirahAzman
 
PPTX
Arrays
Neeru Mittal
 
PPTX
Arrays 1D and 2D , and multi dimensional
Appili Vamsi Krishna
 
PDF
ARRAYS
muniryaseen
 
PDF
Array and Pointers
Prof Ansari
 
PPT
Data Structure Midterm Lesson Arrays
Maulen Bale
 
PDF
Chap 6 c++
Venkateswarlu Vuggam
 
PPT
Multi dimensional arrays
Aseelhalees
 
PPT
Chap 6 c++
Venkateswarlu Vuggam
 
PPT
Lecture 15 - Array
Md. Imran Hossain Showrov
 
PPTX
Arrays in programming
TaseerRao
 
Arrays in C++
Ilio Catallo
 
arrays.pptx
HarmanShergill5
 
Generative Coding Lecture notes using coding
ssuserff773c
 
Unit4 Slides
Anurag University Hyderabad
 
Array
Mayank Saxena
 
Basics of Data structure using C describing basics concepts
shanthidl1
 
Python Datatypes by SujithKumar
Sujith Kumar
 
Visual Programing basic lectures 7.pptx
Mrhaider4
 
Chap1 array
raksharao
 
Chapter 13.pptx
AnisZahirahAzman
 
Arrays
Neeru Mittal
 
Arrays 1D and 2D , and multi dimensional
Appili Vamsi Krishna
 
ARRAYS
muniryaseen
 
Array and Pointers
Prof Ansari
 
Data Structure Midterm Lesson Arrays
Maulen Bale
 
Chap 6 c++
Venkateswarlu Vuggam
 
Multi dimensional arrays
Aseelhalees
 
Chap 6 c++
Venkateswarlu Vuggam
 
Lecture 15 - Array
Md. Imran Hossain Showrov
 
Arrays in programming
TaseerRao
 

More from Ilio Catallo (20)

PDF
C++ Standard Template Library
Ilio Catallo
 
PDF
Regular types in C++
Ilio Catallo
 
PDF
Resource wrappers in C++
Ilio Catallo
 
PDF
Memory management in C++
Ilio Catallo
 
PDF
Operator overloading in C++
Ilio Catallo
 
PDF
Pointers & References in C++
Ilio Catallo
 
PDF
Spring MVC - Wiring the different layers
Ilio Catallo
 
PDF
Java and Java platforms
Ilio Catallo
 
PDF
Spring MVC - Web Forms
Ilio Catallo
 
PDF
Spring MVC - The Basics
Ilio Catallo
 
PDF
Web application architecture
Ilio Catallo
 
PDF
Introduction To Spring
Ilio Catallo
 
PDF
Gestione della memoria in C++
Ilio Catallo
 
PDF
Array in C++
Ilio Catallo
 
PDF
Puntatori e Riferimenti
Ilio Catallo
 
PDF
Java Persistence API
Ilio Catallo
 
PDF
JSP Standard Tag Library
Ilio Catallo
 
PDF
Internationalization in Jakarta Struts 1.3
Ilio Catallo
 
PDF
Validation in Jakarta Struts 1.3
Ilio Catallo
 
PDF
Introduction to Struts 1.3
Ilio Catallo
 
C++ Standard Template Library
Ilio Catallo
 
Regular types in C++
Ilio Catallo
 
Resource wrappers in C++
Ilio Catallo
 
Memory management in C++
Ilio Catallo
 
Operator overloading in C++
Ilio Catallo
 
Pointers & References in C++
Ilio Catallo
 
Spring MVC - Wiring the different layers
Ilio Catallo
 
Java and Java platforms
Ilio Catallo
 
Spring MVC - Web Forms
Ilio Catallo
 
Spring MVC - The Basics
Ilio Catallo
 
Web application architecture
Ilio Catallo
 
Introduction To Spring
Ilio Catallo
 
Gestione della memoria in C++
Ilio Catallo
 
Array in C++
Ilio Catallo
 
Puntatori e Riferimenti
Ilio Catallo
 
Java Persistence API
Ilio Catallo
 
JSP Standard Tag Library
Ilio Catallo
 
Internationalization in Jakarta Struts 1.3
Ilio Catallo
 
Validation in Jakarta Struts 1.3
Ilio Catallo
 
Introduction to Struts 1.3
Ilio Catallo
 

Recently uploaded (20)

PDF
Encapsulation_ Review paper, used for researhc scholars
gurumoop
 
PDF
Dropbox Q2 2025 Financial Results & Investor Presentation
Dropbox
 
PDF
Chapter 3 Spatial Domain Image Processing.pdf
Getnet Tigabie Askale -(GM)
 
PDF
Machine learning based COVID-19 study performance prediction
IAESIJAI
 
PPTX
Cloud computing and distributed systems.
kkkkkhan
 
PDF
NewMind AI Weekly Chronicles - August'25 Week I
NewMind AI
 
PDF
Blue Purple Modern Animated Computer Science Presentation.pdf.pdf
Akar16
 
PPT
Teaching material agriculture food technology
LiaRayya
 
PPTX
VMware vSphere Foundation How to Sell Presentation-Ver1.4-2-14-2024.pptx
blackmambaettijean
 
PDF
Mobile App Security Testing_ A Comprehensive Guide.pdf
flufftailshop
 
PDF
Optimiser vos workloads AI/ML sur Amazon EC2 et AWS Graviton
Julien SIMON
 
PDF
Network Security Unit 5.pdf for BCA BBA.
Serpent6
 
PPTX
Effective Security Operations Center (SOC) A Modern, Strategic, and Threat-In...
ReZa AdineH
 
PDF
Building Integrated photovoltaic BIPV_UPV.pdf
SandeepSingh286037
 
PDF
Electronic commerce courselecture one. Pdf
OmerMohamed64
 
PPTX
ACSFv1EN-58255 AWS Academy Cloud Security Foundations.pptx
23bcla24
 
PDF
Per capita expenditure prediction using model stacking based on satellite ima...
IAESIJAI
 
PPTX
Spectroscopy.pptx food analysis technology
nawahassan45
 
PDF
Review of recent advances in non-invasive hemoglobin estimation
IAESIJAI
 
PDF
KodekX | Application Modernization Development
KodekX
 
Encapsulation_ Review paper, used for researhc scholars
gurumoop
 
Dropbox Q2 2025 Financial Results & Investor Presentation
Dropbox
 
Chapter 3 Spatial Domain Image Processing.pdf
Getnet Tigabie Askale -(GM)
 
Machine learning based COVID-19 study performance prediction
IAESIJAI
 
Cloud computing and distributed systems.
kkkkkhan
 
NewMind AI Weekly Chronicles - August'25 Week I
NewMind AI
 
Blue Purple Modern Animated Computer Science Presentation.pdf.pdf
Akar16
 
Teaching material agriculture food technology
LiaRayya
 
VMware vSphere Foundation How to Sell Presentation-Ver1.4-2-14-2024.pptx
blackmambaettijean
 
Mobile App Security Testing_ A Comprehensive Guide.pdf
flufftailshop
 
Optimiser vos workloads AI/ML sur Amazon EC2 et AWS Graviton
Julien SIMON
 
Network Security Unit 5.pdf for BCA BBA.
Serpent6
 
Effective Security Operations Center (SOC) A Modern, Strategic, and Threat-In...
ReZa AdineH
 
Building Integrated photovoltaic BIPV_UPV.pdf
SandeepSingh286037
 
Electronic commerce courselecture one. Pdf
OmerMohamed64
 
ACSFv1EN-58255 AWS Academy Cloud Security Foundations.pptx
23bcla24
 
Per capita expenditure prediction using model stacking based on satellite ima...
IAESIJAI
 
Spectroscopy.pptx food analysis technology
nawahassan45
 
Review of recent advances in non-invasive hemoglobin estimation
IAESIJAI
 
KodekX | Application Modernization Development
KodekX
 

Multidimensional arrays in C++

  • 1. Mul$dimensional arrays Ilio Catallo - info@iliocatallo.it
  • 2. Outline • Arrays of arrays • Arrays of arrays vs. pointers • Pointer arithme4c • Arrays of arrays vs. func4ons • The array of arrays type • Bibliography
  • 4. How to define an array Arrays are defined by specifying: • The type common to each element • The name of the array • Its size
  • 5. How to define an array int numbers[4]; • Element type: int • Name: numbers • Size: 4
  • 6. Array representa+on 0 ... 3 ┌───┬───┬───┬───┐ numbers: │ │ │ │ │ int[4] └───┴───┴───┴───┘
  • 7. Type aliases C++ supports type aliases, i.e., new names for previously defined types1 using integer = int; integer a = 5; // the same as: int a = 5 1 Star'ng from C++11, type aliases can be introduced by means of the using keyword (in addi'on to the already available typedef keyword)
  • 8. Type aliases for array types We can introduce type aliases for array types as well. For instance, let us introduce a type alias for the type int[4] using int4 = int[4];
  • 9. Type aliases for array types We can now define numbers in terms of the type alias int4 using int4 = int[4]; int4 numbers = {1, 7, 13, 10};
  • 10. Can we now take advantage of our newly-defined alias to define an array of, e.g., 3 elements of type int4?
  • 11. Array of int4's int4 m[3]; • Element type: ? • Name: ? • Size: ?
  • 12. Array of int4's int4 m[3]; • Element type: int4 • Name: m • Size: 3
  • 13. Arrays of arrays Since each element of m is in turn an array, we have effec6vely defined an array of arrays int4 m[3];
  • 14. Arrays of arrays Specifically, m is an array of 3 elements, where each element is in turn an array of 4 elements int4 m[3];
  • 15. Array arrays representa+on 0 1 2 ┌─────────────────────┬─────────────────────┬─────────────────────┐ │ ┌───┬───┬───┬───┐ │ ┌───┬───┬───┬───┐ │ ┌───┬───┬───┬───┐ │ m: │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ int4[3] │ └───┴───┴───┴───┘ │ └───┴───┴───┴───┘ │ └───┴───┴───┴───┘ │ └─────────────────────┴─────────────────────┴─────────────────────┘
  • 16. Ini$alizing an array We know that arrays can be ini1alized using an ini#alizer list int numbers[4] = {1, 7, 13, 10};
  • 17. Ini$alizing an array In case of numbers, the ini.alizer list is composed of int values // 1 is a int, 7 is a int, ... int numbers[4] = {1, 7, 13, 10};
  • 18. Ini$alizing an array of arrays In case of m, the ini.alizer list is composed of int4 values using int4 = int[4]; int4 m[3] = { {1, 7, 14, 2}, // {1, 7, 14, 2} is an int4 {8, 16, 12, 10}, // {8, 16, 12, 10} is an int4 {27, 32, 5, 15} }; // {27, 32, 5, 15} is an int4
  • 19. Accessing inner elements It would be convenient to be able to access inner elements in m using int4 = int[4]; int4 m[3] = { {1, 7, 14, 2}, {8, 16, 12, 10}, {27, 32, 5, 15} };
  • 20. Accessing inner elements For example, being able to access the element in (2, 1) using int4 = int[4]; int4 m[3] = { {1, 7, 14, 2}, {8, 16, 12, 10}, {27, 32, 5, 15} };
  • 21. Accessing inner elements In order to do so, it is sufficient to specify the right amount of indices (as many as the number of dimensions) m[2][1]
  • 22. Accessing inner elements In order to do so, it is sufficient to specify the right amount of indices (as many as the number of dimensions) m[2][1] → {27, 32, 5, 15}[1]
  • 23. Accessing inner elements In order to do so, it is sufficient to specify the right amount of indices (as many as the number of dimensions) m[2][1] → {27, 32, 5, 15}[1] → 32
  • 24. Accessing inner elements using int4 = int[4]; int4 m[3] = { {1, 7, 14, 2}, {8, 16, 12, 10}, {27, 32, 5, 15} }; std::cout << m[2][1]; // output: 32
  • 25. Mul$dimensional arrays Note that m can therefore act as a mul$dimensional array, and, specifically, it can be treated as a matrix
  • 26. Mul$dimensional arrays Mul$dimensional arrays extend the concept of array to one or more dimensions
  • 27. Mul$dimensional arrays For common arrays, elements are addressed by specifying one index ┌───┬───┬───┬───┐ │ │ │ │ │ └───┴───┴───┴───┘ ▲ │ i
  • 28. Mul$dimensional arrays For mul(dimensional arrays, each element is iden(fied by a tuple of indexes (as many as the number of dimensions) ┌───┬───┬───┬───┐ │ │ │ │ │ ├───┼───┼───┼───┤ │ │ │ │ │ ├───┼───┼───┼───┤ │ │ │ │ │◀─── i └───┴───┴───┴───┘ ▲ │ j
  • 29. Arrays of arrays C++ does not provide proper mul1dimensional arrays. Instead, mul1dimensional arrays are approximated as arrays of arrays
  • 30. Memory layout Since mul*dim. arrays are approximated as arrays of arrays, it follows that elements are organized in memory as a sequence m[0] m[1] m[2] ◀──────────────▶◀────────────▶◀─────────────▶ ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┐ m: │ │ │ │ │ │ │ │ │ │ │ │ │ int4[3] └───┴───┴───┴───┴───┴───┴───┴───┴───┴───┴───┴───┘
  • 31. Arrays of arrays vs. pointers
  • 32. Pointer to first element Assume we want to store the address of the first element of m // {1, 7, 14, 2} is the 1st element int4 m[3] = { {1, 7, 14, 2}, {8, 16, 12, 10}, {27, 32, 5, 15} };
  • 33. Pointer to first element We start by no,cing that the element type of m is int4 int4 m[3] = { {1, 7, 14, 2}, // {1, 7, 14, 2} is an int4 {8, 16, 12, 10}, // {8, 16, 12, 10} is an int4 {27, 32, 5, 15} }; // {27, 32, 5, 15} is an int4
  • 34. Pointer to first element Since the element type is equal to int4, a pointer2 to any element in the array has to be of type int4* using int4 = int[4]; int4* first = ... 2 The int4 type alias provides a convenient way to introduce pointers to arrays. Without the intermediate type alias, one would define first to be of type int(*)[4], which is arguably less readable
  • 35. What to write on the RHS? using int4 = int[4]; int4 m[3] = { {1, 7, 14, 2}, {8, 16, 12, 10}, {27, 32, 5, 15} }; int4* first = ???
  • 36. What to write on the RHS? using int4 = int[4]; int4 m[3] = { {1, 7, 14, 2}, {8, 16, 12, 10}, {27, 32, 5, 15} }; int4* first = &m[0]; // the address of {1, 7, 14, 2}
  • 37. Pointer decay As with any array, pointer decay can be used using int4 = int[4]; int4 m[3] = { {1, 7, 14, 2}, {8, 16, 12, 10}, {27, 32, 5, 15} }; // array-to-pointer decay (int4[3] → int4*) int4* first = m;
  • 38. Pointer decay ┌ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ┐ 0 1 2 │┌─────────────────────┬┼────────────────────┬─────────────────────┐ │ ┌───┬───┬───┬───┐ │ ┌───┬───┬───┬───┐ │ ┌───┬───┬───┬───┐ │ m: ││ │ │ │ │ │ ││ │ │ │ │ │ │ │ │ │ │ │ │ int4[3] │ └───┴───┴───┴───┘ │ └───┴───┴───┴───┘ │ └───┴───┴───┴───┘ │ │└─────────────────────┴┼────────────────────┴─────────────────────┘ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ▲ │ │ │ │ ┌───┐ first:│ │ int4* └───┘
  • 40. Pointer arithme,c Given that arrays of arrays are only a par1cular case of arrays, pointer arithme,c can be applied on them without any special considera1on
  • 41. Pointer arithme,c: addi,on using int4 = int[4]; int4 m[3] = { {1, 7, 14, 2}, {8, 16, 12, 10}, {27, 32, 5, 15} }; int4* first = m; // ptr to {1, 7, 14, 2} int4* second = m + 1; // ptr to {8, 16, 12, 10} int4* third = m + 2; // ptr to {27, 32, 5, 15}
  • 42. Pointer arithme,c No#ce that pointer arithme#c allows moving between the rows of our 2-dimensional array m int4* first = m; // ptr to {1, 7, 14, 2} int4* second = m + 1; // ptr to {8, 16, 12, 10} int4* third = m + 2; // ptr to {27, 32, 5, 15}
  • 43. Deriving the indexing operator Let us now try to reduce inner element access to a sequence of pointer arithme,c opera,ons
  • 44. Deriving the indexing operator To this end, let us consider the following expression: m[2][1]
  • 45. Deriving the indexing operator By replacing [1] with its defini3on we obtain: m[2][1] → *(m[2] + 1)
  • 46. Deriving the indexing operator If we do the same for [2] we obtain: m[2][1] → *(m[2] + 1) → *(*(m + 2) + 1)
  • 47. Indexing operator on arrays of arrays Accessing inner elements of a array of arrays is therefore s2ll defined in terms of pointer arithme,c Given an array of arrays m, and a pair of indexes i and j, the opera3on a[i][j] is implemented as *(*(m + i) + j)
  • 48. Arrays of arrays vs. func.ons
  • 49. The sum_int func)on Assume we would like to write a func3on named sum_int, which computes the summa3on of all the elements in a 2-dimensional array
  • 50. What we know • We can model 2-dimensional arrays as arrays of arrays • Arrays of arrays follow the same rules as normal arrays • We cannot pass arrays by value • The common workaround is to design func>ons that accept a pointer to the 1st element, together with the array size
  • 51. An interface for sum_int As a first step, let us write sum_int so that it works properly when m is fed as an input using int4 = int[4]; int4 m[3] = { {1, 7, 14, 2}, {8, 16, 12, 10}, {27, 32, 5, 15} };
  • 52. An interface for sum_int int sum_int(??? first, ??? n);
  • 53. An interface for sum_int int sum_int(int4* first, std::size_t n);
  • 54. An interface for sum_int Since we want sum_int to work with m, we impose first to be of type int4 int sum_int(int4* first, std::size_t n);
  • 55. An interface for sum_int Hence, sum_int can only work with 2-dimensional arrays of exactly 4 columns int sum_int(int4* first, std::size_t n);
  • 56. An interface for sum_int int sum_int(int4* first, std::size_t n); • The number of rows is determined by the parameter n • The number of columns is fixed by the type of first (int4)
  • 57. An interface for sum_int If we need to work with 2-dimensional arrays of, e.g., 5 columns, we need to write a new func(on4 int sum_int(int4* first, std::size_t n); int sum_int5(int5* first, std::size_t n); 4 This can be automated by using a func%on template
  • 58. sum_int → sum_int4 In light of this, let us rename sum_int as sum_int4 int sum_int4(int4* first, std::size_t n);
  • 59. Implemen'ng sum_int4 int sum_int4(int4* first, std::size_t n) { int sum = 0; for (std::size_t i = 0; i < n; ++i) for (std::size_t j = 0; j < 4; ++j) sum += ??? return sum; }
  • 60. Implemen'ng sum_int4 int sum_int4(int4* first, std::size_t n) { int sum = 0; for (std::size_t i = 0; i < n; ++i) for (std::size_t j = 0; j < 4; ++j) sum += *(*(first + i) + j); return sum; }
  • 61. Implemen'ng sum_int4 int sum_int4(int4* first, std::size_t n) { int sum = 0; for (std::size_t i = 0; i < n; ++i) for (std::size_t j = 0; j < 4; ++j) sum += first[i][j]; return sum; }
  • 62. Invoking sum_int4 int main() { using int4 = int[4]; int4 m[3] = { {1, 7, 14, 2}, {8, 16, 12, 10}, {27, 32, 5, 15} }; int r = sum_int4(???, ???); std::cout << "the elements sum up to " << r; }
  • 63. Invoking sum_int4 int main() { using int4 = int[4]; int4 m[3] = { {1, 7, 14, 2}, {8, 16, 12, 10}, {27, 32, 5, 15} }; int r = sum_int4(m, 3); std::cout << "the elements sum up to " << r; }
  • 64. The array of arrays type
  • 65. The int4 type alias Up to now, we took advantage of the int4 type alias for the defini7on of m using int4 = int[4]; int4 m[3] = { {1, 7, 14, 2}, {8, 16, 12, 10}, {27, 32, 5, 15} };
  • 66. The int4 type alias We did so in order to stress the true nature of mul1dimensional arrays in C++ using int4 = int[4]; int4 m[3] = { {1, 7, 14, 2}, {8, 16, 12, 10}, {27, 32, 5, 15} };
  • 67. The data type of m A"er introducing int4, we can say that m is of type int4[3] (i.e., an array of 3 elements of type int4) using int4 = int[4]; int4 m[3] = { {1, 7, 14, 2}, {8, 16, 12, 10}, {27, 32, 5, 15} };
  • 68. The data type of m However, one could wonder how to express the data type of m without introducing the int4 type alias ??? m[3] = { {1, 7, 14, 2}, {8, 16, 12, 10}, {27, 32, 5, 15} };
  • 69. The data type of m This amounts to asking what is the result of applying the [3] type constructor on int[4]
  • 70. Applying [3] on int Construct a type "array of 3 elements of type int" Input type int Type constructor: [3] Output type: int[3]
  • 71. Applying [3] on int[4] Construct a type "array of 3 elements of type int[4]" Input type: int[4] Type constructor: [3] Output type: int[3][4]
  • 72. The data type of m Therefore, we conclude that m is of type int[3][4] int m[3][4] = { {1, 7, 14, 2}, {8, 16, 12, 10}, {27, 32, 5, 15} };
  • 73. Arrays of arrays The common C++ syntax for defining arrays of arrays gives the illusion of working with mul;dimensional arrays int m[3][4] = { {1, 7, 14, 2}, {8, 16, 12, 10}, {27, 32, 5, 15} };
  • 74. Arrays of arrays However - though the syntax would suggest otherwise - the element type of m is s8ll int[4], not int int m[3][4] = { {1, 7, 14, 2}, {8, 16, 12, 10}, {27, 32, 5, 15} };
  • 75. The alterna*ve signature As with normal arrays, C++ admits func6on signatures that may appear more natural when dealing with mul6dimensional arrays
  • 76. The alterna*ve signature Namely, we can change the signature of sum_int4 from this... int sum_int4(int4* first, std::size_t n);
  • 77. The alterna*ve signature ...to this: int sum_int4(int m[][4], std::size_t n);
  • 78. The alterna*ve signature int sum_int4(int m[][4], std::size_t n) { int sum = 0; for (std::size_t i = 0; i < n; ++i) for (std::size_t j = 0; j < 4; ++j) sum += m[i][j]; return sum; }
  • 80. Bibliography • S.B. Lippman et al., C++ Primer (5th Ed.) • B. Stroustrup, The C++ Programming Language (4th Ed.) • StackOverflow FAQ, "How do I use arrays in C++?"