#include "pch.h"
#include <iostream>
#include "limitarr.h"
#include "ArrayDb.h";
const int arrlen = 4;

int main() {
  LimitArr lim1(arrlen, 20, 10);
  cout << lim1;
  for (int i = 20; i < 24; i++)
    lim1[i] = i + 100;
  cout << lim1;
  cout << lim1[22] << "\n";
  ArrayDb & ra = lim1;
  ArrayDb * pa = &lim1;
  ra[22] = 88.87;
  (*pa)[21] = 66;
  cout << lim1;
  system("pause");
  return 0;
}


//////////////


// arraydb.h ‐‐ define array class
#ifndef _ARRAYDB_H_
#define _ARRAYDB_H_
#include <ostream>
#include <iostream>
using namespace std;
class ArrayDb {
private:
  int size; // number of array elements
protected:
  double * arr; // address of first element
public:
  ArrayDb(); // default constructor
  // create an ArrayDb of n elements, set each to val
  ArrayDb(int n, double val = 0.0);
  // create an ArrayDb of n elements, initialize to array pn
  ArrayDb(const double * pn, unsigned int n);
  ArrayDb(const ArrayDb & a); // copy constructor
  virtual ~ArrayDb(); // destructor
  unsigned int arsize() const { return size; } // returns array size
  // overloaded operators
  virtual double & operator[](int i); // array indexing
  virtual const double & operator[](int i) const; // array indexing (no =)
  ArrayDb & operator=(const ArrayDb & a);
  friend std::ostream & operator<<(std::ostream & os, const ArrayDb & a);
};
#endif






//#include "stdafx.h"
#include <pch.h>
#include <iostream>
#include <stdlib.h> // exit() prototype
#include "arraydb.h"
// default constructor ‐‐ no arguments
ArrayDb::ArrayDb() {
  arr = NULL;
  size = 0;
}
// constructs array of n elements, each set to val
ArrayDb::ArrayDb(int n, double val) {
  arr = new double[n];
  size = n;
  for (int i = 0; i < size; i++)
    arr[i] = val;
}
// initialize ArrayDb object to a non‐class array
ArrayDb::ArrayDb(const double *pn, unsigned int n) {
  arr = new double[n];
  size = n;
  for (int i = 0; i < size; i++)
    arr[i] = pn[i];
}
// initialize ArrayDb object to another ArrayDb object
ArrayDb::ArrayDb(const ArrayDb & a) {
  size = a.size;
  arr = new double[size];
  for (int i = 0; i < size; i++)
    arr[i] = a.arr[i];
}
ArrayDb::~ArrayDb() {
  delete[] arr;
}
// let user access elements by index (assignment allowed)
double & ArrayDb::operator[](int i) {
  // check index before continuing
  if (i < 0 || i >= size) {
    std::cout << "Error in array limits: "
      << i << " is a bad index\n";
    exit(1);
  }
  return arr[i];
}
// let user access elements by index (assignment disallowed)
const double & ArrayDb::operator[](int i) const {
  // check index before continuing
  if (i < 0 || i >= size) {
    std::cout << "Error in array limits: "
      << i << " is a bad index\n";
    exit(1);
  }
  return arr[i];
}
// define class assignment
ArrayDb & ArrayDb::operator=(const ArrayDb & a) {
  if (this == &a) // if object assigned to self,
    return *this; // don't change anything
  delete arr;
  size = a.size;
  arr = new double[size];
  for (int i = 0; i < size; i++)
    arr[i] = a.arr[i];
  return *this;
}
// quick output, 5 values to a line
std::ostream & operator<<(std::ostream & os, const ArrayDb & a) {
  int i;
  for (i = 0; i < a.size; i++) {
    os << a.arr[i] << " ";
    if (i % 5 == 4)
      os << "\n";
  }
  if (i % 5 != 0)
    os << "\n";
  return os;
}










#include "pch.h"
#include "LimitArr.h"
#include <iostream>
#include <stdlib.h>

LimitArr::LimitArr(void) :ArrayDb() {
  l_bound = 0;
}
LimitArr::LimitArr(int n, double val) : ArrayDb(n, val) {
  l_bound = 0;
}

LimitArr::LimitArr(int n, int lb, double val) : ArrayDb(n, val) {
  l_bound = lb;
}

LimitArr::LimitArr(const double * pn, int n, int lb) : ArrayDb(pn, n) {
  l_bound = lb;
}
LimitArr::LimitArr(const LimitArr & a) : ArrayDb(a) {
  l_bound = a.l_bound;
}
LimitArr::LimitArr(const ArrayDb & a) : ArrayDb(a) {
  l_bound = 0;
}
LimitArr::~LimitArr(void) {
}
void LimitArr::new_lb(int lb) {
  l_bound = lb;
}
int LimitArr::lbound() {
  return l_bound;
}
int LimitArr::ubound() {
  return l_bound + arsize() - 1;
}
double & LimitArr::operator[](int i) {
  return arr[i - l_bound];
}
const double & LimitArr::operator[](int i) const {
  return arr[i - l_bound];
}








#pragma once
#ifndef _LIMARR_H_
#define _LIMARR_H_
#include "ArrayDb.h"
class LimitArr :
  public ArrayDb {
protected:
  int low_bnd;
  void ok(int i) const;
public:
  LimitArr(void);
  LimitArr(int n, double val = 0.0);
  LimitArr(int n, int lb, double val = 0.0);
  //where lb is lower bond of array
  LimitArr(const double * pn, int n, int lb = 0);
  LimitArr(const LimitArr & a);
  LimitArr(const ArrayDb & a);
  ~LimitArr(void);

  int l_bound;

  void new_lb(int lb);// reset lower bound
  int lbound(); // return lower bound
  int ubound(); // return upper bound

  double & operator[](int i); // array indexing
  const double & operator[](int i) const; // array indexing (no =)

};
#endif