연산자 오버로드에 대해 불평하는 게시물이 많이 있습니다.
나는 "운영자 과부하"개념을 명확히해야한다고 생각하여이 개념에 대한 대안적인 견해를 제시했다.
코드 난독 화?
이 주장은 잘못된 것입니다.
모든 언어에서 난독 처리가 가능합니다 ...
연산자 오버로드를 통해 C ++ 에서처럼 함수 / 메소드를 통해 C 또는 Java로 코드를 난독 처리하는 것이 쉽습니다.
// C++
T operator + (const T & a, const T & b) // add ?
{
T c ;
c.value = a.value - b.value ; // subtract !!!
return c ;
}
// Java
static T add (T a, T b) // add ?
{
T c = new T() ;
c.value = a.value - b.value ; // subtract !!!
return c ;
}
/* C */
T add (T a, T b) /* add ? */
{
T c ;
c.value = a.value - b.value ; /* subtract !!! */
return c ;
}
... Java의 표준 인터페이스에서도
또 다른 예를 들어, 자바로 Cloneable인터페이스 를 보자 :
이 인터페이스를 구현하는 객체를 복제해야합니다. 그러나 당신은 거짓말을 할 수 있습니다. 그리고 다른 객체를 만듭니다. 실제로이 인터페이스는 너무 약해서 재미를 위해 다른 유형의 객체를 모두 반환 할 수 있습니다.
class MySincereHandShake implements Cloneable
{
public Object clone()
{
return new MyVengefulKickInYourHead() ;
}
}
애즈 Cloneable인터페이스 남용 될 수 / 난독, 이는 C ++ 연산자 오버로딩이 있어야하는데 동일한 이유로 금지되어야 하는가?
우리 toString()는 MyComplexNumber클래스 의 메소드를 오버로드하여 문자열 화 된 시간을 반환하도록 할 수 있습니다. toString()과부하도 금지 해야합니까 ? 우리 MyComplexNumber.equals는 임의의 값을 반환하고 피연산자 등을 수정하도록 방해 할 수 있습니다.
Java에서 C ++ 또는 다른 언어와 마찬가지로 프로그래머는 코드를 작성할 때 최소한의 의미를 존중해야합니다. 즉 add, 추가 하는 기능과 Cloneable복제하는 구현 방법 및 ++증분보다 연산자를 구현 해야합니다 .
어쨌든 뭐가 난독 해?
이제 원시 Java 메소드를 통해서도 코드가 파괴 될 수 있음을 알았으므로 C ++에서 연산자 오버로드의 실제 사용에 대해 스스로에게 물어볼 수 있습니까?
명확하고 자연스러운 표기법 : 메서드와 연산자 오버로딩?
Java와 C ++의 "동일한"코드를 아래에서 비교하여 어떤 코딩 스타일이 더 명확한 지 알 수 있습니다.
자연 비교 :
// C++ comparison for built-ins and user-defined types
bool isEqual = A == B ;
bool isNotEqual = A != B ;
bool isLesser = A < B ;
bool isLesserOrEqual = A <= B ;
// Java comparison for user-defined types
boolean isEqual = A.equals(B) ;
boolean isNotEqual = ! A.equals(B) ;
boolean isLesser = A.comparesTo(B) < 0 ;
boolean isLesserOrEqual = A.comparesTo(B) <= 0 ;
연산자 오버로드가 제공되는 한 A 및 B는 C ++에서 모든 유형이 될 수 있습니다. Java에서 A와 B가 프리미티브가 아닌 경우 프리미티브와 유사한 객체 (BigInteger 등)의 경우에도 코드가 매우 혼란 스러울 수 있습니다 ...
자연스러운 배열 / 컨테이너 접근 자 및 아래 첨자 :
// C++ container accessors, more natural
value = myArray[25] ; // subscript operator
value = myVector[25] ; // subscript operator
value = myString[25] ; // subscript operator
value = myMap["25"] ; // subscript operator
myArray[25] = value ; // subscript operator
myVector[25] = value ; // subscript operator
myString[25] = value ; // subscript operator
myMap["25"] = value ; // subscript operator
// Java container accessors, each one has its special notation
value = myArray[25] ; // subscript operator
value = myVector.get(25) ; // method get
value = myString.charAt(25) ; // method charAt
value = myMap.get("25") ; // method get
myArray[25] = value ; // subscript operator
myVector.set(25, value) ; // method set
myMap.put("25", value) ; // method put
Java에서는 각 컨테이너가 동일한 작업을 수행하기 위해 (인덱스 또는 식별자를 통해 내용에 액세스) 다른 방법으로 수행하는 것이 혼란 스럽습니다.
C ++에서 연산자 오버로드 덕분에 각 컨테이너는 동일한 방식으로 콘텐츠에 액세스합니다.
자연스러운 고급 유형 조작
아래 예 Matrix는 Google에서 " Java Matrix object "및 " C ++ Matrix object " 에 대한 첫 번째 링크를 사용하여 찾은 객체를 사용합니다 .
// C++ YMatrix matrix implementation on CodeProject
// http://www.codeproject.com/KB/architecture/ymatrix.aspx
// A, B, C, D, E, F are Matrix objects;
E = A * (B / 2) ;
E += (A - B) * (C + D) ;
F = E ; // deep copy of the matrix
// Java JAMA matrix implementation (seriously...)
// http://math.nist.gov/javanumerics/jama/doc/
// A, B, C, D, E, F are Matrix objects;
E = A.times(B.times(0.5)) ;
E.plusEquals(A.minus(B).times(C.plus(D))) ;
F = E.copy() ; // deep copy of the matrix
그리고 이것은 행렬에만 국한되지 않습니다. BigInteger와 BigDecimal자바의 클래스는 C에서 자신의 등가물 ++로 반면, 같은 혼란 상세 고통 내장의 유형으로 취소합니다.
자연 반복자 :
// C++ Random Access iterators
++it ; // move to the next item
--it ; // move to the previous item
it += 5 ; // move to the next 5th item (random access)
value = *it ; // gets the value of the current item
*it = 3.1415 ; // sets the value 3.1415 to the current item
(*it).foo() ; // call method foo() of the current item
// Java ListIterator<E> "bi-directional" iterators
value = it.next() ; // move to the next item & return the value
value = it.previous() ; // move to the previous item & return the value
it.set(3.1415) ; // sets the value 3.1415 to the current item
자연 펑터 :
// C++ Functors
myFunctorObject("Hello World", 42) ;
// Java Functors ???
myFunctorObject.execute("Hello World", 42) ;
텍스트 연결 :
// C++ stream handling (with the << operator)
stringStream << "Hello " << 25 << " World" ;
fileStream << "Hello " << 25 << " World" ;
outputStream << "Hello " << 25 << " World" ;
networkStream << "Hello " << 25 << " World" ;
anythingThatOverloadsShiftOperator << "Hello " << 25 << " World" ;
// Java concatenation
myStringBuffer.append("Hello ").append(25).append(" World") ;
자, Java MyString = "Hello " + 25 + " World" ;에서도 사용할 수 있습니다 ... 그러나 잠시만 기다리십시오. 이것은 연산자 오버로드입니다. 그렇지 않습니까? 부정 행위 아닌가요 ???
:-디
일반 코드?
내장 / 프리미티브 (Java에 인터페이스가없는), 표준 객체 (올바른 인터페이스를 가질 수 없음) 및 사용자 정의 객체 모두에 동일한 일반 코드 수정 피연산자를 사용할 수 있습니다.
예를 들어, 임의 유형의 두 값의 평균값을 계산합니다.
// C++ primitive/advanced types
template<typename T>
T getAverage(const T & p_lhs, const T & p_rhs)
{
return (p_lhs + p_rhs) / 2 ;
}
int intValue = getAverage(25, 42) ;
double doubleValue = getAverage(25.25, 42.42) ;
complex complexValue = getAverage(cA, cB) ; // cA, cB are complex
Matrix matrixValue = getAverage(mA, mB) ; // mA, mB are Matrix
// Java primitive/advanced types
// It won't really work in Java, even with generics. Sorry.
운영자 과부하 논의
이제 연산자 오버로딩을 사용하는 C ++ 코드와 Java의 동일한 코드를 공정하게 비교 했으므로 이제 "오퍼레이터 오버로드"를 개념으로 설명 할 수 있습니다.
컴퓨터 이전부터 운영자 과부하가 발생했습니다.
심지어 외부 컴퓨터 과학, 연산자 오버로딩이있다 : 예를 들어, 수학, 사업자 좋아 +, -, *오버로드, 등.
실제로,의 의미 + , -,* 등의 변화 피연산자의 종류 (수치 등, 벡터 양자 파동 함수, 행렬)에 따라.
우리 대부분은 과학 과정의 일부로서 피연산자의 유형에 따라 연산자에 대한 여러 가지 의미를 배웠습니다. 혼란 스러웠습니까?
연산자 오버로드는 피연산자에 따라 다릅니다.
이것은 연산자 오버로딩의 가장 중요한 부분입니다. 수학이나 물리학 에서처럼 연산은 피연산자의 유형에 따라 다릅니다.
따라서 피연산자의 유형을 알고 작업의 효과를 알게됩니다.
C와 Java조차도 (하드 코딩 된) 연산자 오버로드가 있습니다.
C에서 연산자의 실제 동작은 피연산자에 따라 변경됩니다. 예를 들어, 두 개의 정수를 추가하는 것은 두 개의 double을 추가하거나 하나의 정수와 double을 추가하는 것과 다릅니다. 전체 포인터 산술 도메인도 있습니다 (캐스팅하지 않고 포인터에 정수를 추가 할 수는 있지만 두 개의 포인터를 추가 할 수는 없습니다 ...).
Java에서는 포인터 산술이 없지만 +"연산자 오버로드가 악의적"이라는 신념에서 예외를 정당화 할만큼 조작자가 없는 문자열 연결은 여전히 우스운 것으로 판명되었습니다 .
C (역사적 이유로) 또는 Java ( 개인적 이유로 아래 참조) 코더 로서 자신만을 제공 할 수는 없습니다.
C ++에서 연산자 오버로딩은 선택 사항이 아닙니다 ...
C ++에서는 내장 유형에 대한 연산자 오버로드가 불가능하지만 (이것은 좋습니다) 사용자 정의 유형에는 사용자 정의 유형이있을 수 있습니다 연산자 오버로드 .
앞서 언급했듯이 C ++ 및 Java와 달리 사용자 유형은 내장 유형과 비교할 때 언어의 2 급 시민으로 간주되지 않습니다. 따라서 내장 유형에 연산자가 있으면 사용자 유형도 연산자를 가질 수 있어야합니다.
진실은 저를 인처럼 toString(), clone(), equals()방법은 자바위한 것입니다 ( 즉, 준 표준 등 ), C ++ 연산자 오버로딩이 언급 Java 메소드 전에 원래 C 사업자 등의 자연, 또는으로 될 것으로 ++ C의 너무 많은 부분입니다.
템플릿 프로그래밍과 결합 된 연산자 오버로딩은 잘 알려진 디자인 패턴이됩니다. 실제로 오버로드 된 연산자를 사용하지 않고 자신의 클래스에 대한 오버로드 연산자를 사용하지 않으면 STL에서 멀리 갈 수 없습니다.
...하지만 남용해서는 안됩니다
연산자 과부하는 연산자의 의미를 존중하기 위해 노력해야합니다. +연산자 에서 빼지 마십시오 ( " add함수 에서 빼지 마십시오 "또는 " clone메소드 에서 크랩 반환 ").
캐스트 과부하는 모호성을 유발할 수 있으므로 매우 위험 할 수 있습니다. 따라서 실제로 정의 된 사례를 위해 예약해야합니다. 에 관해서 &&그리고 ||당신이 정말로 당신이 무슨 일을하는지 알지 못한다면 당신은 기본 운영자 그 단락 회로 평가를 잃게됩니다로서, 지금까지 그들을 과부하가 걸리지 않도록 &&하고 ||즐길 수 있습니다.
그렇다면 ... Ok ... 그렇다면 왜 Java에서는 불가능합니까?
제임스 고슬링이 그렇게 말했기 때문에 :
C ++에서 너무 많은 사람들이 그것을 남용하는 것을 보았 기 때문에 연산자 오버로드를 상당히 개인적인 선택으로 제외 했습니다.
제임스 고슬링 출처 : http://www.gotw.ca/publications/c_family_interview.htm
위의 Gosling의 텍스트를 Stroustrup의 아래 텍스트와 비교하십시오.
많은 C ++ 디자인 결정은 사람들이 특정한 방식으로 일을하도록 강요하는 것에 대해 싫어하는 데 뿌리를두고있다. [...] 종종, 나는 개인적으로 싫어하는 기능을 불법화하려는 유혹을 받았다. 다른 사람에 대한 나의 견해를 강요 할 권리 .
Bjarne Stroustrup. 출처 : C ++의 디자인과 진화 (1.3 일반 배경)
연산자 과부하가 Java에 도움이됩니까?
일부 객체는 연산자 오버로드 (BigDecimal, 복소수, 행렬, 컨테이너, 반복자, 비교기, 파서 등과 같은 콘크리트 또는 숫자 유형)의 이점을 크게 누릴 수 있습니다.
C ++에서는 Stroustrup의 겸손으로 인해이 혜택을 누릴 수 있습니다. Java에서는 Gosling이 개인적으로 선택 했기 때문에 문제가 발생했습니다 .
Java에 추가 할 수 있습니까?
현재 Java에 운영자 과부하를 추가하지 않는 이유는 내부 정치, 기능에 대한 알레르기, 개발자에 대한 불신 (Java 팀을 괴롭히는 것처럼 보이는 파괴자), 이전 JVM과의 호환성, 정확한 사양 작성 시간 등
따라서이 기능을 기다리는 숨을 참지 마십시오 ...
그러나 그들은 C #으로 그것을합니다!
네...
이것이 두 언어의 유일한 차이점은 아니지만이 언어는 결코 나를 즐겁게하지 않습니다.
분명히 C # 사람들은 "모든 프리미티브는 a struct이고 structObject에서 파생됩니다"라는 첫 번째 시도에서 올바르게 얻었습니다.
모든에도 불구하고 FUD 사용 정의 연산자 오버로딩에 대해, 다음과 같은 언어를 지원 : 스칼라 , 다트 , 파이썬 , F 번호 , C #을 , D , 알골 (68) , 스몰 토크 , 그루비 , 펄 6 , C ++, 루비 , 하스켈 , MATLAB , 에펠 , 루아 , Clojure , Fortran 90 , Swift , Ada , Delphi 2005 ...
너무나 많은 다른 (때때로 반대되는) 철학을 가진 많은 언어들이 있지만, 그들은 모두 그 시점에 동의합니다.
생각할 거리...