มาจาก C ++ ถึง Java คำถามที่ไม่ได้รับคำตอบที่ชัดเจนคือทำไม Java จึงไม่รวมตัวดำเนินการมากเกินไป?

ไม่Complex a, b, c; a = b + c;ง่ายกว่านี้Complex a, b, c; a = b.add(c);หรือ

มีเหตุผลที่รู้จักกันในเรื่องนี้ข้อโต้แย้งที่ถูกต้องสำหรับการไม่อนุญาตให้ผู้ประกอบการมากเกินไป? เหตุผลโดยพลการหรือเสียเวลา?

สมมติว่าคุณต้องการเขียนทับค่าก่อนหน้าของวัตถุที่อ้างถึงโดยaฟังก์ชันสมาชิกจะต้องถูกเรียกใช้

Complex a, b, c;
// ...
a = b.add(c);

ใน C ++, การแสดงออกนี้จะบอกคอมไพเลอร์ที่จะสร้างสาม (3) วัตถุในกองดำเนินการนอกจากนี้และคัดลอกaค่าผลลัพธ์จากวัตถุชั่วคราวเป็นวัตถุที่มีอยู่

อย่างไรก็ตามใน Java operator=จะไม่ทำการคัดลอกค่าสำหรับประเภทการอ้างอิงและผู้ใช้สามารถสร้างประเภทการอ้างอิงใหม่ไม่ใช่ประเภทค่า ดังนั้นสำหรับประเภทที่ผู้ใช้กำหนดชื่อการComplexมอบหมายหมายถึงการคัดลอกการอ้างอิงไปยังค่าที่มีอยู่

พิจารณาแทน:

b.set(1, 0); // initialize to real number '1'
a = b; 
b.set(2, 0);
assert( !a.equals(b) ); // this assertion will fail

ใน C ++ นี่เป็นการคัดลอกค่าดังนั้นการเปรียบเทียบจะส่งผลไม่เท่ากัน ใน Java operator=ดำเนินการอ้างอิงการคัดลอกเพื่อให้aและbตอนนี้หมายถึงค่าเดียวกัน เป็นผลให้การเปรียบเทียบจะสร้าง 'เท่ากัน' เนื่องจากวัตถุจะเปรียบเทียบเท่ากับตัวเอง

ความแตกต่างระหว่างการคัดลอกและการอ้างอิงจะเพิ่มความสับสนของผู้ปฏิบัติงานมากเกินไป ดังที่ @Sebastian ได้กล่าวถึง Java และ C # ทั้งสองจะต้องจัดการกับค่าและความเท่าเทียมกันของการอ้างอิงแยกต่างหาก - operator+น่าจะจัดการกับค่าและวัตถุ แต่operator=มีการใช้งานแล้วเพื่อจัดการกับการอ้างอิง

ใน C ++ คุณควรจัดการกับการเปรียบเทียบครั้งละหนึ่งประเภทเท่านั้นดังนั้นจึงอาจทำให้สับสนน้อยลง ตัวอย่างเช่นในComplex, operator=และoperator==มีทั้งที่ทำงานเกี่ยวกับค่า - การคัดลอกค่านิยมและเปรียบเทียบค่าตามลำดับ

มีการโพสต์มากมายที่บ่นเกี่ยวกับการบรรทุกเกินพิกัด

ฉันรู้สึกว่าต้องอธิบายแนวคิด "โอเปอเรเตอร์การบรรทุกเกินพิกัด" เพื่อเสนอมุมมองทางเลือกในแนวคิดนี้

รหัสทำให้งง?

อาร์กิวเมนต์นี้เป็นความเข้าใจผิด

การทำให้งงเป็นไปได้ในทุกภาษา ...

มันเป็นเรื่องง่ายที่จะทำให้งงงวยรหัสใน C หรือ Java ผ่านฟังก์ชั่น / วิธีการที่มันเป็นใน C ++ ผ่านการดำเนินการเกินพิกัด:

// 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อินเตอร์เฟสใน Java:

คุณควรจะโคลนวัตถุที่ใช้อินเตอร์เฟซนี้ แต่คุณสามารถโกหก และสร้างวัตถุต่าง ๆ ในความเป็นจริงอินเทอร์เฟซนี้อ่อนแอดังนั้นคุณสามารถส่งคืนวัตถุชนิดอื่นพร้อมกันเพียงเพื่อความสนุก:

class MySincereHandShake implements Cloneable
{
    public Object clone()
    {
       return new MyVengefulKickInYourHead() ;
    }
}

เนื่องจากCloneableอินเตอร์เฟซสามารถถูกใช้ในทางที่ผิด / obfuscated มันควรถูกแบนในบริเวณเดียวกันกับตัวดำเนินการ 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ชั้นเรียนของ Java ต้องทนทุกข์ทรมานจากความสับสนฟุ่มเฟื่อยเดียวกันขณะที่เทียบเท่าใน 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" ;... แต่รอสักครู่: นี่คือการใช้งานตัวดำเนินการมากเกินไปใช่ไหม? มันไม่ใช่การโกงหรอ ???

:-D

รหัสทั่วไป?

ตัวดำเนินการแก้ไขรหัสทั่วไปที่เหมือนกันควรจะสามารถใช้งานได้ทั้งสำหรับบิวด์อิน / ตัวดั้งเดิม (ซึ่งไม่มีส่วนต่อประสานใน 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 ตอนนี้เราสามารถพูดถึง "ตัวดำเนินการเกินพิกัด" เป็นแนวคิด

ผู้ประกอบการเกินพิกัดที่มีอยู่ตั้งแต่ก่อนคอมพิวเตอร์

แม้ภายนอกของวิทยาศาสตร์คอมพิวเตอร์ที่มีการดำเนินงานมาก: ตัวอย่างเช่นในวิชาคณิตศาสตร์ประกอบการชอบ+, -, *ฯลฯ มีมากเกินไป

อันที่จริงความหมายของ+, -, *ฯลฯ การเปลี่ยนแปลงขึ้นอยู่กับชนิดของตัวถูกดำเนินการที่ (numerics เวกเตอร์, ฟังก์ชั่นคลื่นควอนตัม, การฝึกอบรม ฯลฯ )

พวกเราส่วนใหญ่ซึ่งเป็นส่วนหนึ่งของหลักสูตรวิทยาศาสตร์ของเราได้เรียนรู้ความสำคัญหลายประการสำหรับผู้ประกอบการขึ้นอยู่กับประเภทของตัวถูกดำเนินการ เราพบว่าพวกเขาสับสนพวกเขา?

ผู้ประกอบการมากไปขึ้นอยู่กับตัวถูกดำเนินการ

นี่เป็นส่วนที่สำคัญที่สุดของการบรรทุกเกินพิกัด: เช่นเดียวกับในคณิตศาสตร์หรือในฟิสิกส์การดำเนินการขึ้นอยู่กับประเภทของตัวถูกดำเนินการ

ดังนั้นรู้ประเภทของตัวถูกดำเนินการและคุณจะรู้ผลของการดำเนินการ

แม้แต่ C และ Java ก็ยังมีผู้ให้บริการโหลดมากเกินไป

ใน C พฤติกรรมที่แท้จริงของผู้ปฏิบัติงานจะเปลี่ยนไปตามตัวถูกดำเนินการ ตัวอย่างเช่นการเพิ่มสองจำนวนเต็มแตกต่างจากการเพิ่มสองคู่หรือแม้กระทั่งหนึ่งจำนวนเต็มและหนึ่งคู่ มีแม้กระทั่งโดเมนเลขคณิตทั้งตัวชี้ (โดยไม่ต้องร่ายคุณสามารถเพิ่มจำนวนเต็มให้กับตัวชี้ แต่คุณไม่สามารถเพิ่มสองพอยน์เตอร์ ... )

ใน Java ไม่มีตัวชี้ทางคณิตศาสตร์ แต่บางคนยังพบว่าการต่อสตริงโดยไม่มีตัว+ดำเนินการจะไร้สาระมากพอที่จะพิสูจน์ข้อยกเว้นใน "โอเปอเรเตอร์การบรรทุกเกินพิกัดเป็นความชั่วร้าย"

เป็นเพียงแค่คุณในฐานะ C (สำหรับเหตุผลทางประวัติศาสตร์) หรือ Java (สำหรับเหตุผลส่วนตัวดูด้านล่าง) coder คุณไม่สามารถให้บริการของคุณเอง

ใน C ++ ตัวดำเนินการมากไปไม่ใช่ตัวเลือก ...

ใน C ++ การโอเวอร์โหลดของผู้ประกอบการสำหรับประเภทในตัวเป็นไปไม่ได้ (และนี่เป็นสิ่งที่ดี) แต่ประเภทที่ผู้ใช้กำหนดเองสามารถมีตัวดำเนินการที่ผู้ใช้กำหนดเองมากเกินไป

ดังที่ได้กล่าวไปแล้วก่อนหน้านี้ใน C ++ และในทางตรงกันข้ามกับ Java ประเภทผู้ใช้จะไม่ถือว่าเป็นพลเมืองชั้นสองของภาษาเมื่อเทียบกับประเภทในตัว ดังนั้นหากประเภทในตัวมีตัวดำเนินการประเภทผู้ใช้ก็ควรจะมีเช่นกัน

ความจริงก็คือเหมือนtoString(), clone(), equals()วิธีการสำหรับ Java ( เช่นกึ่งมาตรฐานเหมือน ), C ++ มากไปประกอบเป็นส่วนหนึ่งมากจาก C ++ ที่จะกลายเป็นธรรมชาติเป็นผู้ประกอบการเดิม C หรือก่อน Java วิธีการที่กล่าวถึง

เมื่อรวมกับการเขียนโปรแกรมแม่แบบการใช้งานมากเกินไปกลายเป็นรูปแบบการออกแบบที่รู้จักกันดี ในความเป็นจริงคุณไม่สามารถไปไกลได้ใน STL โดยไม่ต้องใช้โอเปอเรเตอร์ที่โอเวอร์โหลดและโอเปอร์เรเตอร์สำหรับคลาสของคุณเอง

... แต่ไม่ควรถูกทำร้าย

การบรรทุกเกินพิกัดของผู้ประกอบการควรพยายามเคารพความหมายของผู้ปฏิบัติงาน อย่าลบใน+โอเปอเรเตอร์ (เช่น "ห้ามลบในaddฟังก์ชั่น" หรือ "คืนอึในcloneเมธอด")

การบรรทุกมากเกินไปอาจเป็นอันตรายได้เพราะอาจทำให้เกิดความคลุมเครือ ดังนั้นจึงควรสำรองไว้สำหรับกรณีที่กำหนดไว้อย่างดี สำหรับ&&และ||ไม่เคยเกินพวกเขาจนกว่าคุณจะรู้ว่าสิ่งที่คุณกำลังทำเพราะคุณจะสูญเสียการประเมินการลัดวงจรที่ผู้ประกอบการพื้นเมือง&&และ||เพลิดเพลิน

ดังนั้น ... ตกลง ... แล้วทำไมมันเป็นไปไม่ได้ใน Java?

เพราะ James Gosling พูดอย่างนั้น:

ฉันออกจากการใช้งานเกินกำลังเป็นทางเลือกที่ค่อนข้างเป็นส่วนตัวเพราะฉันเห็นคนจำนวนมากเกินไปใช้มันใน 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 อาจเป็นการรวมตัวกันของการเมืองภายในการแพ้ต่อคุณสมบัติความไม่ไว้วางใจของนักพัฒนา เวลาที่จะเขียนข้อมูลจำเพาะที่ถูกต้อง ฯลฯ

ดังนั้นอย่ากลั้นหายใจรอคุณสมบัตินี้ ...

แต่พวกเขาทำใน C # !!!

ใช่...

แม้ว่าสิ่งนี้จะห่างไกลจากความแตกต่างเพียงอย่างเดียวระหว่างสองภาษา แต่สิ่งนี้ไม่เคยทำให้ฉันผิดหวัง

เห็นได้ชัดว่า C # folks ด้วย"ทุกดั้งเดิมคือstructและstructมาจากวัตถุ"ทำให้ถูกต้องตั้งแต่ครั้งแรก

และพวกเขาทำมันในภาษาอื่น ๆ !!!

แม้จะมี FUD ทั้งหมดกับการใช้งานเกินพิกัดที่กำหนดไว้แล้วภาษาต่อไปนี้รองรับ: Scala , Dart , Python , F # , C # , D , Algol 68 , Smalltalk , Groovy , Perl 6 , C ++, ทับทิม , Haskell , MATLAB , Eiffel , Lua , Clojure , Fortran 90 , Swift , Ada , Delphi 2005 ...

ภาษาจำนวนมากที่มีปรัชญา (และบางครั้งก็เป็นปฏิปักษ์) ที่แตกต่างกันมากมาย

อาหารสมอง...

James Gosling เปรียบการออกแบบ Java ดังต่อไปนี้:

"มีหลักการนี้เกี่ยวกับการเคลื่อนย้ายเมื่อคุณย้ายจากอพาร์ทเมนต์หนึ่งไปยังอพาร์ทเมนต์อื่นการทดลองที่น่าสนใจคือการบรรจุอพาร์ทเมนต์ของคุณและใส่ทุกอย่างลงในกล่อง กำลังทำอาหารมื้อแรกของคุณและคุณกำลังดึงอะไรบางอย่างออกมาจากกล่องหลังจากนั้นประมาณหนึ่งเดือนคุณก็เคยคิดว่าสิ่งใดในชีวิตที่คุณต้องการจริง ๆ แล้วคุณก็เอาส่วนที่เหลือ อะไร - ลืมไปว่าคุณชอบมันมากแค่ไหนและมันยอดเยี่ยมแค่ไหนและคุณก็ทิ้งมันไปได้มันวิเศษมากที่ทำให้ชีวิตของคุณง่ายขึ้นและคุณสามารถใช้หลักการนั้นกับปัญหาการออกแบบทุกประเภทได้ เจ๋งหรือแค่เพราะน่าสนใจ "

คุณสามารถอ่านบริบทของคำพูดได้ที่นี่

โดยทั่วไปการบรรทุกเกินพิกัดนั้นยอดเยี่ยมสำหรับคลาสที่มีรูปแบบของจุดสกุลเงินหรือจำนวนเชิงซ้อน แต่หลังจากนั้นคุณก็เริ่มหมดตัวอย่างรวดเร็ว

ปัจจัยอีกประการหนึ่งคือการใช้งานคุณลักษณะใน C ++ โดยนักพัฒนาซอฟต์แวร์มากเกินไปเช่น '&&', '||', ผู้ดำเนินการส่งและแน่นอน 'ใหม่' ความซับซ้อนที่เกิดจากการรวมสิ่งนี้กับการผ่านค่าและข้อยกเว้นได้รับการกล่าวถึงในหนังสือC ++ชั้นยอด

ลองใช้ Boost.Units: ลิงก์ข้อความ

มันให้การวิเคราะห์มิติศูนย์ค่าใช้จ่ายผ่านการบรรทุกเกินพิกัด สิ่งนี้จะมีความชัดเจนมากขึ้น

quantity<force>     F = 2.0*newton;
quantity<length>    dx = 2.0*meter;
quantity<energy>    E = F * dx;
std::cout << "Energy = " << E << endl;

จะเอาท์พุท "พลังงาน = 4 J" ที่ถูกต้อง

นักออกแบบ Java ตัดสินใจว่าการใช้งานเกินกำลังเป็นปัญหามากกว่าที่ควรจะเป็น เรียบง่ายเหมือนที่

ในภาษาที่ตัวแปรออบเจคต์ทุกตัวเป็นตัวอ้างอิงจริงการดำเนินการมากไปของตัวดำเนินการจะได้รับอันตรายเพิ่มเติมจากการที่ไม่สมเหตุผลกับโปรแกรมเมอร์ C ++ อย่างน้อยที่สุด เปรียบเทียบสถานการณ์กับ C # 's == โอเปอเรเตอร์การบรรทุกเกินพิกัดและObject.EqualsและObject.ReferenceEquals(หรือสิ่งที่เรียกว่า)

Groovyมีผู้ให้บริการโหลดมากเกินไปและทำงานใน JVM หากคุณไม่สนใจเรื่องประสิทธิภาพ (ซึ่งเล็กลงทุกวัน) มันเป็นไปโดยอัตโนมัติตามชื่อเมธอด เช่น '+' เรียกวิธีการ 'บวก (อาร์กิวเมนต์)'

ฉันคิดว่านี่อาจเป็นตัวเลือกการออกแบบที่ใส่ใจเพื่อบังคับให้นักพัฒนาสร้างฟังก์ชั่นที่ชื่อมีการสื่อสารความตั้งใจของพวกเขาอย่างชัดเจน ในนักพัฒนา C ++ จะโอเวอร์โหลดโอเปอเรเตอร์ที่มีฟังก์ชั่นซึ่งมักจะไม่เกี่ยวข้องกับลักษณะที่ยอมรับกันโดยทั่วไปของโอเปอเรเตอร์ที่กำหนดทำให้แทบจะเป็นไปไม่ได้เลยที่จะกำหนดว่าโค้ดใดบ้าง

คุณสามารถถ่ายภาพตัวเองด้วยการเดินเท้าของผู้ปฏิบัติงานมากไป มันเหมือนกับคนพอยน์เตอร์ที่ทำผิดพลาดโง่ ๆ กับพวกเขาดังนั้นจึงตัดสินใจเอากรรไกรออกไป

อย่างน้อยฉันก็คิดว่านั่นเป็นเหตุผล ฉันอยู่ข้างคุณแล้ว :)

บางคนบอกว่าตัวดำเนินการมากเกินไปใน Java จะนำไปสู่ ​​obsfuscation คนเหล่านั้นเคยหยุดดูจาวาโค้ดบางตัวที่ทำคณิตศาสตร์พื้นฐานเช่นการเพิ่มมูลค่าทางการเงินโดยใช้เปอร์เซ็นต์ BigDecimal หรือไม่? .... การใช้คำฟุ่มเฟื่อยของการออกกำลังกายดังกล่าวกลายเป็นของตัวเองของ obsfuscation กระแทกแดกดันการเพิ่มผู้ประกอบการมากไปยังจาวาจะช่วยให้เราสามารถสร้างระดับสกุลเงินของเราซึ่งจะทำให้รหัสทางคณิตศาสตร์ดังกล่าวสง่างามและเรียบง่าย (น้อย obsfuscated)

การกล่าวว่าตัวดำเนินการมากเกินไปนำไปสู่ข้อผิดพลาดเชิงตรรกะของประเภทที่ตัวดำเนินการที่ไม่ตรงกับตรรกะการดำเนินงานมันก็เหมือนไม่มีอะไรพูด ข้อผิดพลาดประเภทเดียวกันจะเกิดขึ้นหากชื่อฟังก์ชั่นไม่เหมาะสมสำหรับตรรกะการดำเนินการ - ดังนั้นอะไรคือทางออก: ลดความสามารถในการใช้ฟังก์ชัน! นี่คือคำตอบที่ตลก - "ไม่เหมาะสมสำหรับตรรกะการดำเนินงาน", ชื่อพารามิเตอร์ทุกตัว, ทุกคลาส, ฟังก์ชั่นหรืออะไรก็ตามที่ไม่เหมาะสมในเชิงตรรกะ ฉันคิดว่าตัวเลือกนี้ควรมีให้ในภาษาโปรแกรมที่น่าเชื่อถือและผู้ที่คิดว่าไม่ปลอดภัย - เฮ้ไม่มีทั้งคู่บอกว่าคุณต้องใช้มัน ให้ใช้ C # พวกเขาหลบเลี่ยงพอยน์เตอร์ แต่เดี๋ยวก่อน - มีคำสั่ง 'รหัสที่ไม่ปลอดภัย' - โปรแกรมตามที่คุณต้องการโดยความเสี่ยงของคุณเอง

ในทางเทคนิคมีการใช้งานตัวดำเนินการมากเกินไปในทุกภาษาการเขียนโปรแกรมที่สามารถจัดการกับตัวเลขประเภทต่าง ๆ เช่นจำนวนเต็มและจำนวนจริง คำอธิบาย: คำว่าการใช้งานมากเกินไปหมายถึงมีการปรับใช้หลายอย่างสำหรับหนึ่งฟังก์ชันเท่านั้น ในภาษาการเขียนโปรแกรมส่วนใหญ่มีการใช้งานที่แตกต่างกันสำหรับโอเปอเรเตอร์ + หนึ่งรายการสำหรับจำนวนเต็มหนึ่งรายการสำหรับ reals ซึ่งเรียกว่าโอเปอเรเตอร์การบรรทุกเกินพิกัด

ตอนนี้หลายคนพบว่ามันแปลกที่ Java มีตัวดำเนินการบรรทุกเกินพิกัดสำหรับตัวดำเนินการ + สำหรับการเพิ่มสตริงเข้าด้วยกันและจากจุดยืนทางคณิตศาสตร์นี้จะแปลกแน่นอน แต่เห็นได้จากมุมมองของนักพัฒนาภาษาโปรแกรมไม่มีอะไรผิด สำหรับโอเปอเรเตอร์ + สำหรับคลาสอื่นเช่นสตริง อย่างไรก็ตามคนส่วนใหญ่ยอมรับว่าเมื่อคุณเพิ่ม builtin overloading สำหรับ + ​​สำหรับ String แล้วโดยทั่วไปก็เป็นความคิดที่ดีที่จะให้ฟังก์ชั่นนี้สำหรับนักพัฒนาเช่นกัน

ไม่เห็นด้วยอย่างสมบูรณ์กับการเข้าใจผิดที่ผู้ประกอบการใช้งานเกินพิกัดทำให้งงงวยรหัสเนื่องจากจะเหลือสำหรับนักพัฒนาในการตัดสินใจ นี่ไร้เดียงสาที่จะคิดและพูดตามตรงแล้วมันค่อนข้างเก่า

+1 สำหรับการเพิ่มโอเปอเรเตอร์การโหลดใน Java 8

สมมติว่า Java เป็นภาษาที่ใช้งานแล้ว a, b และ c ทั้งหมดจะอ้างอิงถึงการพิมพ์คอมเพล็กซ์ที่มีค่าเริ่มต้นเป็นโมฆะ นอกจากนี้สมมติว่า Complex ไม่มีการเปลี่ยนแปลงตามBigInteger ที่กล่าวถึงและBigDecimal ที่ไม่เปลี่ยนรูปแบบที่คล้ายกันฉันคิดว่าคุณหมายถึงสิ่งต่อไปนี้เนื่องจากคุณกำหนดการอ้างอิงไปยัง Complex ที่ส่งคืนจากการเพิ่ม b และ c และไม่เปรียบเทียบการอ้างอิงนี้กับ

ไม่ใช่:

Complex a, b, c; a = b + c;

มากง่ายกว่า:

Complex a, b, c; a = b.add(c);

บางครั้งมันจะดีถ้ามีโอเปอเรเตอร์การบรรทุกเกินพิกัดคลาสเพื่อนและการสืบทอดหลายรายการ

อย่างไรก็ตามฉันยังคิดว่ามันเป็นการตัดสินใจที่ดี หาก Java มีการใช้งานตัวดำเนินการมากเกินไปเราก็ไม่อาจมั่นใจได้ถึงความหมายของตัวดำเนินการโดยไม่ต้องดูซอร์สโค้ด ในปัจจุบันที่ไม่จำเป็น และฉันคิดว่าตัวอย่างของคุณในการใช้วิธีการแทนการใช้งานมากเกินไปก็สามารถอ่านได้เช่นกัน หากคุณต้องการทำให้สิ่งต่าง ๆ ชัดเจนยิ่งขึ้นคุณสามารถเพิ่มความคิดเห็นข้างบนคำสั่งขน

// a = b + c
Complex a, b, c; a = b.add(c);

นี่ไม่ใช่เหตุผลที่ดีที่จะไม่อนุญาต แต่เป็นสิ่งที่ใช้งานได้จริง:

ผู้คนมักจะไม่ใช้มันอย่างรับผิดชอบ ดูตัวอย่างนี้จาก scapy ไลบรารี่ของ Python:

>>> IP()
<IP |>
>>> IP()/TCP()
<IP frag=0 proto=TCP |<TCP |>>
>>> Ether()/IP()/TCP()
<Ether type=0x800 |<IP frag=0 proto=TCP |<TCP |>>>
>>> IP()/TCP()/"GET / HTTP/1.0\r\n\r\n"
<IP frag=0 proto=TCP |<TCP |<Raw load='GET / HTTP/1.0\r\n\r\n' |>>>
>>> Ether()/IP()/IP()/UDP()
<Ether type=0x800 |<IP frag=0 proto=IP |<IP frag=0 proto=UDP |<UDP |>>>>
>>> IP(proto=55)/TCP()
<IP frag=0 proto=55 |<TCP |>>

นี่คือคำอธิบาย:

/ โอเปอเรเตอร์ถูกใช้เป็นตัวดำเนินการจัดองค์ประกอบระหว่างสองเลเยอร์ เมื่อทำเช่นนั้นเลเยอร์ที่ต่ำกว่าสามารถมีฟิลด์ค่าเริ่มต้นหนึ่งฟิลด์หรือมากกว่านั้นได้โอเวอร์โหลดตามเลเยอร์ด้านบน (คุณยังสามารถให้คุณค่าที่คุณต้องการ) สตริงสามารถใช้เป็นเลเยอร์ดิบ

ทางเลือกในการรองรับ Native ของ Java Operator Overloading

เนื่องจาก Java ไม่มีการใช้งานตัวดำเนินการมากเกินไปนี่เป็นทางเลือกบางประการที่คุณสามารถดูได้:

1. ใช้ภาษาอื่น ทั้งGroovyและScalaมีผู้ให้บริการมากไปและขึ้นอยู่กับ Java
2. ใช้java-ooซึ่งเป็นปลั๊กอินที่ช่วยให้ผู้ให้บริการโหลดมากเกินไปใน Java โปรดทราบว่ามันไม่ได้เป็นแพลตฟอร์มอิสระ นอกจากนี้ยังมีปัญหามากมายและไม่สามารถใช้งานร่วมกับ Java รุ่นล่าสุด (เช่น Java 10) ( ต้นฉบับแหล่ง StackOverflow )
3. ใช้JNI , Java Native Interface หรือทางเลือก สิ่งนี้อนุญาตให้คุณเขียนเมธอด C หรือ C ++ (อาจเป็นอื่นหรือไม่?) เพื่อใช้ใน Java แน่นอนว่านี่ไม่ใช่แพลตฟอร์มอิสระ

หากใครรู้ของผู้อื่นโปรดแสดงความคิดเห็นและฉันจะเพิ่มไปยังรายการนี้

ในขณะที่ภาษา Java ไม่รองรับการโหลดเกินตัวดำเนินการโดยตรงคุณสามารถใช้ปลั๊กอินคอมไพเลอร์ Manifoldในโครงการ Java ใด ๆ เพื่อเปิดใช้งาน รองรับ Java 8 - 13 (เวอร์ชัน Java ปัจจุบัน) และได้รับการสนับสนุนอย่างเต็มที่ใน IntelliJ IDEA