C++ PLEASE include working code 1 Motivation: The C++ long int can only take up

Question

C++

PLEASE include working code

1 Motivation:

The C++ long int can only take up to 64 bits of information, which may not be enough for some scientific computation. In this project, we will design and implement a class named UnsignedLargeInt which will overcome these problems.

The requirement for this project is to use UnsignedLargeInt at almost all situations when int is used.

2 Requirements:

As int, UnsignedLargeInt can be zero or positive. Unlike int, Unsigned- LargeInt has ”infinite” precision and can hold as many digits (char) as pos- sible. The digits are represented by char, and are stored in a dynamically allocated array.

The size of the array can be larger than the actual number of digits in the number. For example, to add two UnsignedLargeInt a1 and a2, the resulted UnsignedLargeInt can have max(a1.len,a2.len) + 1 bytes allocated as the digit array, which is long enough to handle any overflow.

UnsignedLargeInt should have the following operators:

2.1 Constructors and destructor

There are 3 constructors:

default constructor will set the UnsignedLargeInt to zero

copy constructor to take another UnsignedLargeInt as the argument, because we are working with a dynamically allocated array, you must perform deep copy.

constructor to take a unsigned long long as the argument, and transfer this unsigned long long as digits (char) and store the digits in the array. The argument can be positive or zero, so your UnsignedLargeInt must be able to reflect the sign of the argument.

• Destructor: C++ allows only one version of destructor, and it should delete the char array.

2.2 +, * operators (bonus for *)

These operators should perform exactly as their counter parts in int, i.e.

Each of these operators should take two ”const UnsignedLargeInt&” as arguments and return a UnsignedLargeInt. These operators should be designed and implemented as friend operators. It has no requirement to overload these operators. For example:

2.3

+=, *= operators (bonus for *=)

These operators should perform exactly as their counter parts in int, i.e.

Each of these operators should take a ”const UnsignedLargeInt&” as ar- gument and return ”UnsignedLargeInt&”. It has no requirement to overload these operators.

2.4 boolean operators !, !=, ==, <, >, <=, >=
These operators should perform exactly as their counter parts in int, i.e.

Each of these operator should take two ”const UnsignedLargeInt&” as arguments (except the unary operator ! which will take no argument) and return ”bool”. These operators (except !) should be designed and imple- mented as friend operators. It has no requirement to overload these opera- tors.

2.5 incremental operators ++

These operators should perform exactly as their counter parts in int, and should have two versions (pre-increment and post-increment), i.e.

<< operator
Output the UnsignedLargeInt in a nice format, i.e.

This operator should be friend (just like what we did in the previous pro ject).

2.7 Other requirements

No need to overload the ”>>” operator. Comment you code! Indent your code!

2.6

3 Files to turn in:

You need to turn in four files: makefile, main.C, UnsignedLargeInt.C, Un- signedLargeInt.h. This time, I will not provide a UnsignedLargeInt.h, you need to design your own.

You should have a main.C that can test all your operators.

Explanation / Answer

the principal built-in types are numerics, sequences, mappings, files, classes, instances and exceptions.

Some operations are supported by several object types; in particular, practically all objects can be compared, tested for truth value, and converted to a string (with the repr() function or the slightly different str() function). The latter function is implicitly used when an object is written by the print() function.

Any object can be tested for truth value, for use in an if or while condition or as operand of the Boolean operations below. The following values are considered false:

None

False

zero of any numeric type, for example, 0, 0L, 0.0, 0j.

any empty sequence, for example, '', (), [].

any empty mapping, for example, {}.

instances of user-defined classes, if the class defines a __nonzero__() or __len__() method, when that method returns the integer zero or bool value False. [1]

All other values are considered true — so objects of many types are always true.

Operations and built-in functions that have a Boolean result always return 0 or False for false and 1 or True for true, unless otherwise stated. (Important exception: the Boolean operations or and and always return one of their operands.)

Boolean Operations — and, or, not

These are the Boolean operations, ordered by ascending priority:

Notes:

Objects of different types, except different numeric types and different string types, never compare equal; such objects are ordered consistently but arbitrarily (so that sorting a heterogeneous array yields a consistent result). Furthermore, some types (for example, file objects) support only a degenerate notion of comparison where any two objects of that type are unequal. Again, such objects are ordered arbitrarily but consistently. The <, <=, > and >= operators will raise a TypeError exception when any operand is a complex number.

Non-identical instances of a class normally compare as non-equal unless the class defines the __eq__() method or the __cmp__() method.

Instances of a class cannot be ordered with respect to other instances of the same class, or other types of object, unless the class defines either enough of the rich comparison methods (__lt__(), __le__(), __gt__(), and __ge__()) or the __cmp__() method.

Related Questions

Navigate

• Browse (All)
• Browse C
• Subjects

Integrity-first tutoring: explanations and feedback only — we do not complete graded work. Learn more.