array(array 클래스)

※main.cpp파일

#include <iostream>

#include "array.h"



int main() {

	std::cout << "Array::ARRAYSIZE : " << Array::getDefaultSize() << std::endl;

	Array arr1;

	Array arr2(100);

	int nums[] = {1,2,3,4,5};

	Array arr3(nums,5);

	const Array arr4 = arr3;

	

	arr1 = arr4;

	

	if (arr1 == arr4) {

		std::cout << "arr1 and arr4 are equal" << std::endl;

	} else {

		std::cout << "arr1 and arr4 are not equal" << std::endl;

	}

	

	arr1[0] = arr1[4];

	

	for (int i = 0; i<arr1.size(); ++i) {

		std::cout << arr1[i] << " "; //arr1.operator[](i)

	}

	std::cout << std::endl;

	return 0;

}

※array.h파일

#ifndef ARRAY_H

#define ARRAY_H



//extern const int ARRAYSIZE; //main.cpp에서 다른 파일의 전역변수에 접근할 때는 extern을 써줘야한다.



class Array {

private:

	static const int ARRAYSIZE; 

	// 전역변수이지만 class와 관련된 전역변수는 static으로 써 클래스 안에 둘 수 있다.

	//private에 두면 main에서는 접근불가능

	//public에 두면 main에서 접근가능

	int *pArr_;

	int size_;

public:

	//Array *operator&() const {return this;}

	//const Array *operator&() const {return this;}

	

	static int getDefaultSize();  // static이 붙었기 때문에 멤버함수가 아니라 전역함수이다.

	

	//Array();

	explicit Array(int size = ARRAYSIZE);

	//인자가 1개있는 생성자에서 explicit을 쓰면 명시적으로 설정해주면 Array arr = 100; 처럼 배열을 생성할 수 없다.

	//반드시 Array arr(100);의 형태로 써야한다.

	Array(const Array& rhs);

	Array(const int *pArr, int size);

	~Array();

	

	Array& operator=(const Array& rhs);

	

	bool operator==(const Array& rhs) const;

	

	int& operator[](int index);

	const int& operator[](int index) const;

	

	int size() const;

};

#endif

※array.cpp파일

#include <cassert>

#include "array.h"



//const int ARRAYSIZE = 100; //constant (vs. literal)

const int Array::ARRAYSIZE = 100;

/*Array::Array() 

:pArr_(new int[ARRAYSIZE]),size_(ARRAYSIZE)  //생성자 초기화 리스트 (콜론을 사용해 표시)- 생성자에서만 쓸 수 있음

{

	//pArr_ = new int[ARRAYSIZE];

	assert(pArr_);

	//size_ = ARRAYSIZE;

}

*/



int Array::getDefaultSize() {

	return Array::ARRAYSIZE;

}



Array::Array(int size) 

: pArr_(new int[size]),size_(size)

{

	//pArr_ = new int[size];

	assert(pArr_);

	//size_ = size;

}



Array::Array(const Array& rhs) 

:pArr_(new int[rhs.size_]),size_(rhs.size_)

{

	//pArr_ = new int[rhs.size_];

	assert(pArr_);

	//size_ = rhs.size_;

	for (int i = 0; i<rhs.size(); i++) {

		pArr_[i] = rhs.pArr_[i];

	}

}



Array::Array(const int *pArr,int size) 

:pArr_(new int[size]),size_(size)

{

	//pArr_ = new int[size];

	assert(pArr_);

	//size_ = size;

	

	for (int i = 0; i<size; ++i) {

		pArr_[i] = pArr[i];

	}

}



Array::~Array() {

	delete[] pArr_;

}



Array& Array::operator=(const Array& rhs) {

	if (this != &rhs) {

		delete[] pArr_;

		pArr_ = new int[rhs.size_];

		assert(pArr_);

		size_ = rhs.size_;

		for (int i = 0; i<rhs.size_; ++i) {

			pArr_[i] = rhs.pArr_[i];

		}

	}

	return *this;

}



bool Array::operator==(const Array& rhs) const {

	if (size_ != rhs.size_) 

		return false;

	int i;

	for (i = 0; i<rhs.size_; ++i) {

		if (pArr_[i] != rhs.pArr_[i]) {

			break;

		}

	}

	

	return (i == rhs.size_);

}



int& Array::operator[](int index) {

	return pArr_[index];

}



const int& Array::operator[](int index)const {

	return pArr_[index];

}



int Array::size() const {

	return size_;

}