ความซับซ้อนของวงจรเมื่อเรียกวิธีเดียวกันหลาย ๆ ครั้ง

ขอบคุณสำหรับคำถามที่รีวิวรหัสฉันได้มีความขัดแย้งเล็กน้อย (ซึ่งเป็นโอกาสที่จะเรียนรู้บางสิ่งบางอย่าง) เกี่ยวกับสิ่งที่ซับซ้อน Cyclomatic สำหรับรหัสด้านล่าง

public static void main(String[] args) {
    try {
        thro();
        thro();
        thro();
        thro();
        thro();
        thro();
        thro();
    }
    catch (NullPointerException e) {
    }
}

private static Random random = new Random();

public static void thro() throws NullPointerException {
    if (random.nextBoolean())
        throw new NullPointerException();
    System.out.println("No crash this time");
}

เมื่อเขียนโค้ดนี้ใน Eclipse และใช้ปลั๊กอินตัวชี้วัด Eclipseมันจะบอกฉันว่า McCabe Cyclomatic Complexity สำหรับวิธีหลักคือ 2 และสำหรับthroวิธีที่มันบอกว่า 2

อย่างไรก็ตามมีคนอื่นบอกฉันว่าความซับซ้อนของการโทรthroหลายครั้งคือnumber of calls * method complexityและดังนั้นจึงอ้างว่าความซับซ้อนของวิธีการหลักคือ 7 * 2 = 14

เราวัดสิ่งต่าง ๆ หรือไม่? เราทั้งคู่สามารถแก้ไขได้ไหม? หรือความซับซ้อนตามวัฏจักรจริงคืออะไรที่นี่?

เมื่อฉันเข้าใจสิ่งนี้อย่างถูกต้องความซับซ้อน Cyclomaticของmainคือ 8 - นั่นคือจำนวนของเส้นทางที่เป็นอิสระเชิงเส้นผ่านรหัส คุณอาจได้รับข้อยกเว้นหนึ่งในเจ็ดบรรทัดหรือไม่มีเลย แต่ไม่มีมากกว่าหนึ่งบรรทัด แต่ละ "จุดยกเว้น" ที่เป็นไปได้นั้นสอดคล้องกับเส้นทางที่แตกต่างกันหนึ่งเส้นทางผ่านรหัส

ฉันเดาว่าเมื่อ McCabe คิดค้นเมตริกนั้นเขาไม่มีภาษาการเขียนโปรแกรมยกเว้นการจัดการในใจ

เป็น 'คนอื่น' ฉันจะตอบที่นี่และแม่นยำเกี่ยวกับสิ่งที่ฉันพูด (ซึ่งฉันไม่แม่นยำโดยเฉพาะกับรูปแบบอื่น ๆ )

จากการใช้ตัวอย่างรหัสด้านบนฉันคำนวณความซับซ้อนของวัฏจักรเป็น 8 และฉันมีความคิดเห็นในรหัสเพื่อแสดงวิธีการคำนวณ เพื่ออธิบายเส้นทางฉันจะพิจารณาการวนลูปที่สำเร็จผ่านการเรียกทั้งหมดthro()เป็น 'main' 'code path' (หรือ 'CP = 1'):

public static void main(String[] args) {
  try {
             // This is the 'main' Code Path: CP = 1
    thro();  // this has a branch, can succeed CP=1 or throw CP=2
    thro();  // this has a branch, can succeed CP=1 or throw CP=3
    thro();  // this has a branch, can succeed CP=1 or throw CP=4
    thro();  // this has a branch, can succeed CP=1 or throw CP=5
    thro();  // this has a branch, can succeed CP=1 or throw CP=6
    thro();  // this has a branch, can succeed CP=1 or throw CP=7
    thro();  // this has a branch, can succeed CP=1 or throw CP=8
  }
  catch (NullPointerException e) {
  }
}

ดังนั้นฉันนับ 8 เส้นทางรหัสในวิธีการหลักนี้ซึ่งสำหรับฉันคือความซับซ้อน Cyclomatic ของ 8

ในแง่ของจาวาแต่ละกลไกสำหรับการออกจากฟังก์ชั่นจะนับว่ามีความซับซ้อนดังนั้นวิธีการที่มีสถานะความสำเร็จและอาจเกิดข้อยกเว้นได้ถึง 3 ข้อยกเว้นมี 4 เส้นทางที่มีการบันทึกไว้

ความซับซ้อนของวิธีการที่เรียกใช้ฟังก์ชันดังกล่าวคือ:

CC(method) = 1 + sum (methodCallComplexity - 1)

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