落書きノート

ふと自分が気になった事を書いてます

C++で問題を解く

#include <iostream>

using namespace std;

class q14_1 {
  int v;
public:
  q14_1(int val) : v(val) { cout << "値が" << v << "のメンバを生成。" << endl; }
  ~q14_1() { cout << "値が" << v << "のメンバを破棄。" << endl; }
};

class q14_1_2 {
  q14_1 a, b, c;
public:
  q14_1_2(int aa, int bb, int cc) : a(aa), b(bb), c(cc) { }
};

int main(void){
  q14_1_2 x(1, 2, 3);

  return 0;
}

#include <iostream>

using namespace std;

class Int1 {
  int n;
public:
  class Overflow {};
  class Underflow {};

  Int1(int val = 0) { setter(val); };
  void setter(int num) {
    if(num > 9) {
      throw Overflow();
    } else if (num < 0) {
      throw Underflow();
    }
    n = num;
  }
  int getter() const { return n; }
};

int main(void){
  int v, n1, n2;
  cout << "初期値 : "; cin >> v;
  cout << "代入開始値 : "; cin >> n1;
  cout << "代入終了値 : "; cin >> n2;

  try {
    Int1 x(v);
    for(int i = n1; i <= n2; i++) {
      x.setter(i);
      cout << "xの値は" << x.getter() << "です。" << endl;
    }

  } catch (Int1::Overflow) {
    cout << "オーバーフロー発生!" << endl;
  } catch (Int1::Underflow) {
    cout << "アンダーフロー発生!" << endl;
  }

  return 0;
}

#ifndef __Class_IntArray
#define __Class_IntArray

#include <iostream>
#include <cstdlib>

using namespace std;

class IntArray {
  int n;
  int *vec;
public:
  class rangeOver{
  private:
    IntArray *ident;
    int idx;
  public:
    rangeOver(IntArray *p, int i) : ident(p), idx(i) {}
    int index() { return idx; }
  };

  explicit IntArray(int i) : n(i) { vec = new int[n]; }

  IntArray(const IntArray& x){
    if(&x == this) {
      n = 0;
      vec = NULL;
    } else {
      n = x.n;
      vec = new int[n];
      for(int i = 0; i < n; i++)
        vec[i] = x.vec[i];
    }
  }

  ~IntArray() { delete[] vec }

  int getSize() const { return n; }

  int& operator[](const int& i) const {
    if(i < 0 || i >= n)
      throw rangeOver();
    return vec[i];
  }

  IntArray& operator=(const IntArray& x){
    if(&x != this){
      if(n != x.n) {
        delete[] vec;
        n = x.n;
        vec = new int[n];
      }
      for(int i = 0; i < n; i++){
        vec[i] = x.vec[i];
      }
    }

    return *this;
  }
};

#endif



#ifndef __Class_String
#define __Class_String

#include <iostream>

class String {
  int len;
  char *ptr;
 public:
  String(const char *s = "");
  String(const String& s);
  ~String();
  int length() const { return len; };
  void swap(String& str);
  void erase(int idx);
  void insert(int idx, char ch);
  int find(const String& str) const;
  char& operator[](int i ) { return ptr[i]; }
  String& operator=(const String& str);
  String& operator+=(const String& str);
  friend String operator+(const String& str1, const String& str2);
  friend bool operator==(const String& str1, const String& str2);
  friend bool operator!=(const String& str1, const String& str2);
  friend bool operator< (const String& str1, const String& str2);
  friend bool operator> (const String& str1, const String& str2);
  friend bool operator<=(const String& str1, const String& str2);
  friend bool operator>=(const String& str1, const String& str2);
  friend std::ostream& operator<<(std::ostream& s, const String& str);
  friend std::istream& operator>>(std::istream& s, String& str);
};

#endif





#include <cstring>
#include <iostream>
#include "q14_4.h"

using namespace std;

String::String(const char *s) : len(strlen(s)) {
  ptr = new char[len + 1];
  strcpy(ptr, s);
}

String::String(const String& s) {
  if(&s == this) {
    len = 0;
    ptr = NULL;
  } else {
    len = s.len;
    ptr = new char[len + 1];
    strcpy(ptr, s.ptr);
  }
}

String::~String() {
  if(ptr) delete[] ptr;
}

void String::swap(String& str) {
  int ltmp = len; len = str.len; str.len = ltmp;
  char *ptmp = ptr; ptr = str.ptr; str.ptr = ptmp;
}

void String::erase(int idx) {
  if(idx >= 0 && idx < len) {
    char *t = new char[len--];
    for(int i = 0; i < idx; i++) t[i] = ptr[i];
    for(int i = idx; i < len; i++) t[i] = ptr[i + 1];
    t[len] = '\0';
    delete[] ptr;
    ptr = t;
  }
}

void String::insert(int idx, char ch) {
  if(idx >= 0 && idx < len) {
    char *t = new char[++len + 1];
    t[idx] = ch;
    for(int i = 0; i < idx; i++) t[i] = ptr[i];
    for(int i  = idx + 1; i <= len; i++) t[i] = ptr[i - 1];
    delete[] ptr;
    ptr = t;
  }
}

int String::find(const String& str) const {
  if(str.len > len) return -1;
  int p1 = 0, p2 = 0;
  while(ptr[p1] && str.ptr[p2]) {
    if(ptr[p1] == str.ptr[p2]) {
      p1++;
      p2++;
    } else {
      p1 -= p2 - 1;
      p2 = 0;
    }
  }

  return str.ptr[p2] ? -1 : p1 - p2;
}

String& String::operator=(const String& str) {
  if(this != &str) {
    if(len != str.len) {
      delete[] ptr;
      ptr = new char[str.len + 1];
    }
    strcpy(ptr, str.ptr);
  }
  return *this;
}

String& String::operator+=(const String& str) {
  len += str.len;
  char *temp = new char[len + 1];
  strcat(strcpy(temp, ptr), str.ptr);
  delete[] ptr;
  ptr = temp;
  return *this;
}

String operator+(const String& str1, const String& str2) {
  String temp(str1);
  temp += str2;
  return temp;
}

bool operator==(const String& str1, const String& str2) {
  return str1.len == str2.len && !strcmp(str1.ptr, str2.ptr);
}

bool operator!=(const String& str1, const String& str2) {
  return !(str1 == str2);
}

bool operator<(const String& str1, const String& str2) {
  return strcmp(str1.ptr, str2.ptr) < 0;
}

bool operator>(const String& str1, const String& str2) {
  return strcmp(str1.ptr, str2.ptr) > 0;
}

bool operator<=(const String& str1, const String& str2) {
  return strcmp(str1.ptr, str2.ptr) <= 0;
}

bool operator>=(const String& str1, const String& str2) {
  return strcmp(str1.ptr, str2.ptr) >= 0;
}

ostream& operator<<(ostream& s, const String& str) {
  return s << str.ptr;
}

istream& operator>>(istream& s, String& str) {
  char temp[1024];
  s.getline(temp, 1024);
  if(str.len != strlen(temp)) {
    delete[] str.ptr;
    str.ptr = new char[str.len = strlen(temp) + 1];
  }
  strcpy(str.ptr, temp);
  return s;
}




#ifndef __Class_Matrix
#define __Class_Matrix

#include <iostream>

class Matrix {
  int _height;
  int _width;
  double *ptr;
 public:
  Matrix(int h, int w);
  Matrix(const Matrix&);
  ~Matrix();
  int height() const { return _height; }
  int width() const { return _width; }
  bool equal_size(const Matrix& mat) const {
    return _height == mat._height && _width == mat._width;
  }
  void print(int w = 0) const;
  double* operator[](int idx) const { return ptr + idx * _width; }
  Matrix operator+() const { return *this; }
  Matrix operator-() const;
  Matrix& operator=(const Matrix&);
  Matrix& operator+=(const Matrix&);
  Matrix& operator-=(const Matrix&);
  Matrix& operator*=(const Matrix&);
  Matrix operator+(const Matrix&) const;
  Matrix operator-(const Matrix&) const;
  Matrix operator*(const Matrix&) const;
  bool operator==(const Matrix&) const;
  bool operator!=(const Matrix&) const;
};

#endif

#include <iomanip>
#include <iostream>
#include "q14_5.h"

using namespace std;

Matrix::Matrix(int h, int w) : _height(h > 0 ? h : 1), _width(w > 0 ? w : 1) {
  ptr = new double[_height * _width];
  for(int i = 0; i < _height; i++) {
    for(int j = 0; j < _width; j++) {
      (*this)[i][j] = 0;
    }
  }
}

Matrix::Matrix(const Matrix& mat) {
  if(this != &mat) {
    _height = mat._height;
    _width = mat._width;
    ptr = new double[_height * _width];
    for(int i = 0; i < _height; i++) {
      for(int j = 0; j < _width; j++) {
        (*this)[i][j] = mat[i][j];
      }
    }
  }
}

Matrix::~Matrix() {
  delete[] ptr;
}

void Matrix::print(int w) const {
  for(int i = 0; i < _height; i++) {
    for(int j = 0; j < _width; j++) {
      cout << setw(w) << (*this)[i][j] << ' ';
    }
    cout << endl;
  }
}

Matrix Matrix::operator-() const {
  Matrix temp(_height, _width);
  for(int i = 0; i < _height; i++) {
    for(int j = 0; j < _width; j++) {
      temp[i][j] = -(*this)[i][j];
    }
  }
  return temp;
}

Matrix& Matrix::operator=(const Matrix& mat) {
  if(this != &mat && equal_size(mat)) {
    for(int i = 0; i < _height; i++) {
      for(int j = 0; j < _width; j++) {
        (*this)[i][j] = mat[i][j];
      }
    }
  }
  return *this;
}

Matrix& Matrix::operator+=(const Matrix& mat) {
  if(equal_size(mat)) {
    for(int i = 0; i < _height; i++) {
      for(int j = 0; j < _width; j++) {
        (*this)[i][j] = mat[i][j];
      }
    }
  }
  return *this;
}

Matrix& Matrix::operator-=(const Matrix& mat) {
  if(equal_size(mat)) {
    for(int i = 0; i < _height; i++) {
      for(int j = 0; j < _width; j++) {
        (*this)[i][j] -= mat[i][j];
      }
    }
  }
  return *this;
}

Matrix Matrix::operator+(const Matrix& mat) const {
  Matrix temp(*this);
  return temp += mat;
}

Matrix Matrix::operator-(const Matrix& mat) const {
  Matrix temp(*this);
  return temp -= mat;
}

Matrix Matrix::operator*(const Matrix& mat) const {
  if(_width != mat._height || _height != mat._width)
    return *this;
  Matrix temp(_height, mat._width);
  for(int i = 0; i < _height; i++) {
    for(int j = 0; j < _height; j++) {
      for(int k = 0; k < _width; k++) {
        temp[i][j] += (*this)[i][k] * mat[k][j];
      }
    }
  }
  return temp;
}

bool Matrix::operator==(const Matrix& mat) const {
  if(!equal_size(mat))
    return false;
  for(int i = 0; i < _height; i++) {
    for(int j = 0; j < _width; j++) {
      if((*this)[i][j] != mat[i][j]) {
        return false;
      }
    }
  }
  return true;
}

bool Matrix::operator!=(const Matrix& mat) const {
  return !(*this == mat);
}

%e3%82%b9%e3%82%af%e3%83%aa%e3%83%bc%e3%83%b3%e3%82%b7%e3%83%a7%e3%83%83%e3%83%88-2017-01-20-20-01-02