CBE - Mini-Course - Data Structures - Project (Huge Integer).png

docker.tar.gz

Huge-integer

Manipulating large numbers is a vital tool that is essential across various domains. The challenge arises because the primitive data types provided by C++ cannot handle such large numbers.

You will address this challenge by crafting your HugeInt class in this course. This class has several constructors and assignment operators to facilitate efficient deep copying and features a comprehensive set of arithmetic operations. This class is designed to serve as a backbone for various application developments, providing a practical solution to the complexities posed by large integers.

The course will delve into the transformation of object-oriented programming (OOP) design into abstract data types (ADT). Additionally, you’ll explore the critical aspect of efficiency in designing libraries, emphasizing its significance in developing large-scale applications. By the end, you’ll possess the skills to create efficient and adaptable libraries that adhere to object-oriented principles.

Implementing an Advanced Huge Integer Class

In the context of a signed `HugeInt` class, the proper implementation of a copy constructor, assignment operator (`operator=`), and destructor is essential to ensure correct behavior and prevent issues related to memory management and data integrity. In this lesson, we’ll discuss why these functions are necessary for our `HugeInt` class and provide their appropriate implementation.


# Your implementation
Review each file carefully to understand the task requirements before starting to code.

5
100
200
78927374759690493727283939222737475969049372728393922332957273757217
+3329593827228272737572172737475969049372728393922
-300


// These two functions are already implemented in the backend:
// 1. ostream& operator<<(ostream&, const HugeInt& I)
// 2. HugeInt::HugeInt(string s)
// The implementation of the three functions mentioned above is hidden
// You can assume that they are available to you


void HugeInt::changeDigit(int di, int val) 
                // This is just a testing function
{
    this->Ds[di] = val;
}

/* Uncomment the following and write these three needed functions
HugeInt::HugeInt(const HugeInt& other)
{
    // Write your code
}
HugeInt& HugeInt::operator=(const HugeInt& other)
{
    // Write your code
}
HugeInt::~HugeInt()
{
    // Write your code
}

*/


#include<fstream>
#include<string>
#include<iostream>
using namespace std;
// Define HugeInt.h
class HugeInt
{
    int size;  // size of digits
    int* Ds;  // digit array will store the digits
    bool isNeg;  // numbers can be negative or positive
public:
    HugeInt(string s); // method to assign a huge integer
    friend ostream& operator<<(ostream&, const HugeInt& I); //print an integers on console
    
    /* Uncomment the following

    HugeInt(const HugeInt& other); // Copy constructor
    HugeInt& operator=(const HugeInt& other); // Assignment operator
    ~HugeInt(); // Destructor
    */
    void changeDigit(int di, int val); // This is just a testing function
};

#include "HugeInt.h"
int main()
{
    // Case 1. The code to show shallow copy, for copy constructor
    {
            HugeInt num1("12345");
            HugeInt num2 = num1; // Problematic copy without a proper copy constructor
            num2.changeDigit(0, 9); // changing Unit digit of num2 to 9
            cout << num1 << endl;
            cout << num2 << endl;
    } // The moment we will add destructor, this end of block will 
      // crash the code and num2's Ds will be destroyed and num1's Ds
      // will try to delete the already deleted memory, resulting in 
      // dangling pointer.
    
    // Case 2. The code to show shallow copy, for assignment statement
    {
            HugeInt num1("+12345");
            HugeInt num2("67890");
            num2 = num1; // problemetic, leading to shallow copy 
            num2.changeDigit(0, 9); // changing Unit digit of num2 to 9
            cout << num1 << endl;
            cout << num2 << endl;
    }

	return 0;
}

import React from 'react';
import { shallow, configure } from 'enzyme';
import Adapter from 'enzyme-adapter-react-16';

configure({ adapter: new Adapter() });

import HelloWorld from './app';

var TestResult = function() {
    this.succeeded = false;
    this.reason = "";
    this.input = "";
    this.expected_output = "";
    this.actual_output = "";
}

export const executeTests = function() {

  var results = [];

  result = new TestResult();
  result.input = 'HelloWorld Component';
  result.expected_output = "span containing text 'Hello World'"

  let wrapper = shallow(<HelloWorld />);

  // Call your Challenge function here.

  let type = wrapper.type();
  let testSuccessful = true;
  let failureReason;

  if (type !== 'span') {
    testSuccessful = false;
    failureReason = "You need to render exactly one span HTML element";
  } else if (wrapper.props().children != "Hello World") {
     testSuccessful = false;
     failureReason = "You have rendered wrong message in your span element";
  }

  result.actual_output = wrapper.html();

  if (testSuccessful) {
    result.succeeded = true;
    result.reason = "Succeeded"
  } else {
    result.succeeded = false;
    result.reason = failureReason;
  }

  results.push(result);

  return results;
}


React

Dart

GoJS React

Typescript React

Vue.js

#include <fstream>
#include <string>
#include <iostream>
using namespace std;

class HugeInt
{
    int size;
    int* Ds;
    bool isNeg;

public:
    HugeInt(string s);
    friend ostream& operator<<(ostream& os, const HugeInt& I);

    // New additions
    HugeInt(const HugeInt& other); // Copy constructor
    HugeInt& operator=(const HugeInt& other); // Assignment operator
    ~HugeInt(); // Destructor
};

* **Copy constructor:** In **line 18**, 
the copy constructor creates a new `HugeInt` object by making a copy of an existing object. It ensures that the new object has its own memory space and is independent of the original object. In short, ensures a deep copy. 

* **Assignment operator:** In **line 19**, 
the assignment operator is used to assign the value of one `HugeInt` object to another. It copies the content of the source object into the target object, ensuring they have the same values. In short, it also ensures a deep copy. 

* **Destructor:** In **line 20**, 
the destructor is called when an object of the class is destroyed or goes out of scope. This function releases resources held by the object and performs necessary cleanup operations, such as deallocating memory.

Understand the copy constructor, assignment operator, and destructor for huge integer implementation.


Copy Constructor, Assignment Operator, and Destructor

Understand the copy constructor, assignment operator, and destructor for huge integer implementation.

__default

Copy Constructor, Assignment Operator, and Destructor

Your implementation

Modified `HugeInt` ADT

Copy Constructor, Assignment Operator, and Destructor

Your implementation

Modified HugeInt ADT

Modified `HugeInt` ADT