2.1. Background In C++, fundamental type int is used to store signed integers. If no length modifiers are present (e.g., short, long ), it's guaranteed to have a width of at least 16 bits. In 64-bit systems, it is almost exclusively guaranteed to have width of at least 32 bits. Suppose on our machine an int is 32 bits wide. This means in memory the Operating System (OS) will use a memory box of 32 bits (= 4 bytes) to store an integer of type int. The maximum and minimum value of such an integer are 2^31-1 and -2°31. The 31 here is due to the dedicated sign bit. You can read these values using functions defined in std::numeric_limits . Any integer that is greater than the 2*31-1 or less than -2^31 cannot be

Database System Concepts
7th Edition
ISBN:9780078022159
Author:Abraham Silberschatz Professor, Henry F. Korth, S. Sudarshan
Publisher:Abraham Silberschatz Professor, Henry F. Korth, S. Sudarshan
Chapter1: Introduction
Section: Chapter Questions
Problem 1PE
icon
Related questions
Question

Please look at the following instructions to complete the code (shown in the second picture). In c++. Thank you. 

There are infinite number of integers. It is impossible to store all of them in computer. In this project, you will
implement class BigInt to store integers of unlimited size, as long as they fit in the physical memory.
2.1. Background
In C++, fundamental type int is used to store signed integers. If no length modifiers are present (e.g., short, long ),
it's guaranteed to have a width of at least 16 bits. In 64-bit systems, it is almost exclusively guaranteed to have width
of at least 32 bits. Suppose on our machine an int is 32 bits wide. This means in memory the Operating System (OS)
will use a memory box of 32 bits (= 4 bytes) to store an integer of type int . The maximum and minimum value of
such an integer are 2^31-1 and -2*31. The 31 here is due to the dedicated sign bit. You can read these values using
functions defined in std::numeric_limits . Any integer that is greater than the 231-1 or less than -2^31 cannot be
correctly stored and represented by int .
To store integers of any size, we can design our own variable-length representations of integers as types using classes.
In this project, we define class Bigint for unsigned integers only.
2.2. The BigInt class
2.2.1. Data members
In the BigInt class, an integer is stored in a SLlist , as shown below (and in Biglnt.h). Each item in the list stores
one digit of the integer.
SLList<int> digits;
2.2.2. Methods
You will implement two arithmetic operations for BigInt : addition and subtraction for absolute difference.
In Biglnt.cpp, you should finish operator+ and operator- . They utilize operator overloading in C++. The return value
should be a new BigInt object, i.e, the two operands should not be modified. There should be no leading es for the
results except for e itself.
For example, if we have two BigInt objects that store integer 456 and 1123 , the results of the two operations are as
follows:
ds::BigInt a("456");
ds::BigInt b("1123");
ds::BigInt s = a + b; //s = 1579
ds::BigInt d = a - b; // d = 667
Transcribed Image Text:There are infinite number of integers. It is impossible to store all of them in computer. In this project, you will implement class BigInt to store integers of unlimited size, as long as they fit in the physical memory. 2.1. Background In C++, fundamental type int is used to store signed integers. If no length modifiers are present (e.g., short, long ), it's guaranteed to have a width of at least 16 bits. In 64-bit systems, it is almost exclusively guaranteed to have width of at least 32 bits. Suppose on our machine an int is 32 bits wide. This means in memory the Operating System (OS) will use a memory box of 32 bits (= 4 bytes) to store an integer of type int . The maximum and minimum value of such an integer are 2^31-1 and -2*31. The 31 here is due to the dedicated sign bit. You can read these values using functions defined in std::numeric_limits . Any integer that is greater than the 231-1 or less than -2^31 cannot be correctly stored and represented by int . To store integers of any size, we can design our own variable-length representations of integers as types using classes. In this project, we define class Bigint for unsigned integers only. 2.2. The BigInt class 2.2.1. Data members In the BigInt class, an integer is stored in a SLlist , as shown below (and in Biglnt.h). Each item in the list stores one digit of the integer. SLList<int> digits; 2.2.2. Methods You will implement two arithmetic operations for BigInt : addition and subtraction for absolute difference. In Biglnt.cpp, you should finish operator+ and operator- . They utilize operator overloading in C++. The return value should be a new BigInt object, i.e, the two operands should not be modified. There should be no leading es for the results except for e itself. For example, if we have two BigInt objects that store integer 456 and 1123 , the results of the two operations are as follows: ds::BigInt a("456"); ds::BigInt b("1123"); ds::BigInt s = a + b; //s = 1579 ds::BigInt d = a - b; // d = 667
There are infinite number of integers. It is impossible to store all of them in computer. In this project, you will
implement class BigInt to store integers of unlimited size, as long as they fit in the physical memory.
2.1. Background
In C++, fundamental type int is used to store signed integers. If no length modifiers are present (e.g., short, long ),
it's guaranteed to have a width of at least 16 bits. In 64-bit systems, it is almost exclusively guaranteed to have width
of at least 32 bits. Suppose on our machine an int is 32 bits wide. This means in memory the Operating System (OS)
will use a memory box of 32 bits (= 4 bytes) to store an integer of type int . The maximum and minimum value of
such an integer are 2^31-1 and -2*31. The 31 here is due to the dedicated sign bit. You can read these values using
functions defined in std::numeric_limits . Any integer that is greater than the 231-1 or less than -2^31 cannot be
correctly stored and represented by int .
To store integers of any size, we can design our own variable-length representations of integers as types using classes.
In this project, we define class Bigint for unsigned integers only.
2.2. The BigInt class
2.2.1. Data members
In the BigInt class, an integer is stored in a SLlist , as shown below (and in Biglnt.h). Each item in the list stores
one digit of the integer.
SLList<int> digits;
2.2.2. Methods
You will implement two arithmetic operations for BigInt : addition and subtraction for absolute difference.
In Biglnt.cpp, you should finish operator+ and operator- . They utilize operator overloading in C++. The return value
should be a new BigInt object, i.e, the two operands should not be modified. There should be no leading es for the
results except for e itself.
For example, if we have two BigInt objects that store integer 456 and 1123 , the results of the two operations are as
follows:
ds::BigInt a("456");
ds::BigInt b("1123");
ds::BigInt s = a + b; //s = 1579
ds::BigInt d = a - b; // d = 667
Transcribed Image Text:There are infinite number of integers. It is impossible to store all of them in computer. In this project, you will implement class BigInt to store integers of unlimited size, as long as they fit in the physical memory. 2.1. Background In C++, fundamental type int is used to store signed integers. If no length modifiers are present (e.g., short, long ), it's guaranteed to have a width of at least 16 bits. In 64-bit systems, it is almost exclusively guaranteed to have width of at least 32 bits. Suppose on our machine an int is 32 bits wide. This means in memory the Operating System (OS) will use a memory box of 32 bits (= 4 bytes) to store an integer of type int . The maximum and minimum value of such an integer are 2^31-1 and -2*31. The 31 here is due to the dedicated sign bit. You can read these values using functions defined in std::numeric_limits . Any integer that is greater than the 231-1 or less than -2^31 cannot be correctly stored and represented by int . To store integers of any size, we can design our own variable-length representations of integers as types using classes. In this project, we define class Bigint for unsigned integers only. 2.2. The BigInt class 2.2.1. Data members In the BigInt class, an integer is stored in a SLlist , as shown below (and in Biglnt.h). Each item in the list stores one digit of the integer. SLList<int> digits; 2.2.2. Methods You will implement two arithmetic operations for BigInt : addition and subtraction for absolute difference. In Biglnt.cpp, you should finish operator+ and operator- . They utilize operator overloading in C++. The return value should be a new BigInt object, i.e, the two operands should not be modified. There should be no leading es for the results except for e itself. For example, if we have two BigInt objects that store integer 456 and 1123 , the results of the two operations are as follows: ds::BigInt a("456"); ds::BigInt b("1123"); ds::BigInt s = a + b; //s = 1579 ds::BigInt d = a - b; // d = 667
Expert Solution
trending now

Trending now

This is a popular solution!

steps

Step by step

Solved in 2 steps

Blurred answer
Knowledge Booster
Function Arguments
Learn more about
Need a deep-dive on the concept behind this application? Look no further. Learn more about this topic, computer-science and related others by exploring similar questions and additional content below.
Similar questions
Recommended textbooks for you
Database System Concepts
Database System Concepts
Computer Science
ISBN:
9780078022159
Author:
Abraham Silberschatz Professor, Henry F. Korth, S. Sudarshan
Publisher:
McGraw-Hill Education
Starting Out with Python (4th Edition)
Starting Out with Python (4th Edition)
Computer Science
ISBN:
9780134444321
Author:
Tony Gaddis
Publisher:
PEARSON
Digital Fundamentals (11th Edition)
Digital Fundamentals (11th Edition)
Computer Science
ISBN:
9780132737968
Author:
Thomas L. Floyd
Publisher:
PEARSON
C How to Program (8th Edition)
C How to Program (8th Edition)
Computer Science
ISBN:
9780133976892
Author:
Paul J. Deitel, Harvey Deitel
Publisher:
PEARSON
Database Systems: Design, Implementation, & Manag…
Database Systems: Design, Implementation, & Manag…
Computer Science
ISBN:
9781337627900
Author:
Carlos Coronel, Steven Morris
Publisher:
Cengage Learning
Programmable Logic Controllers
Programmable Logic Controllers
Computer Science
ISBN:
9780073373843
Author:
Frank D. Petruzella
Publisher:
McGraw-Hill Education