ฉันสับสนกับฟังก์ชั่นขั้นต่ำและสูงสุดในบางบริบท

ในบริบทเดียวเมื่อคุณใช้ฟังก์ชั่นเพื่อรับค่าที่มากหรือน้อยกว่าสองค่าก็จะไม่มีปัญหา ตัวอย่างเช่น,

//how many autographed CD's can I give out?
int howManyAutographs(int CDs, int Cases, int Pens)
{
    //if no pens, then I cannot sign any autographs
    if (Pens == 0)
        return 0;

    //I cannot give away a CD without a case or a case without a CD
    return min(CDs, Cases);
}

ง่าย. แต่ในบริบทอื่นฉันสับสน หากฉันพยายามตั้งค่าสูงสุดหรือต่ำสุดฉันจะย้อนกลับ

//return the sum, with a maximum of 255
int cappedSumWRONG(int x, int y)
{
    return max(x + y, 255); //nope, this is wrong
}

//return the sum, with a maximum of 255
int cappedSumCORRECT(int x, int y)
{
    return min(x + y, 255); //much better, but counter-intuitive to my mind
}

มันไม่ได้ตั้งใจที่จะทำให้ฟังก์ชั่นของตัวเองดังต่อไปนี้?

//return x, with a maximum of max
int maximize(int x, int max)
{
    return min(x, max);
}

//return x, with a minimum of min
int minimize(int x, int min)
{
    return max(x, min)
}

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

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

แทนที่จะใช้ชื่อ“ โอเวอร์โหลด” ชื่อที่ใช้โดยไลบรารีมาตรฐานให้ใช้ชื่อใหม่ที่สื่อความหมายอย่างชัดเจน ในกรณีของคุณคุณไม่สนใจ "ต่ำสุด" จริงๆ แต่คุณต้องการกำหนดมูลค่า ในทางคณิตศาสตร์นี่เป็นการดำเนินการเดียวกัน แต่ความหมายมันไม่มาก ดังนั้นทำไมไม่เพียงแค่ฟังก์ชั่น

int cap(int value, int limit) { return (value > limit) ? limit : value; }

นั่นคือสิ่งที่จำเป็นและบอกจากชื่อของมัน (คุณสามารถนำไปใช้capในแง่ของminตามที่แสดงในคำตอบของtimster )

ชื่อฟังก์ชั่นอื่น ๆ clampอีกที่ใช้บ่อยคือ มันใช้เวลาสามข้อโต้แย้งและ "ยึด" ค่าที่กำหนดไว้ในช่วงเวลาที่กำหนดโดยอีกสองค่า

int clamp(int value, int lower, int upper) {
    assert(lower <= upper);  // precondition check
    if (value < lower) return lower;
    else if (value > upper) return upper;
    else return value;
}

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

ถ้าคุณทำฟังก์ชั่นแบบนั้นซึ่งminimize(4, 10)ส่งคืน10แล้วฉันจะบอกว่ามันไม่เหมาะสมเพราะโปรแกรมเมอร์ของคุณอาจบีบคอคุณ

(โอเคบางทีพวกเขาอาจจะไม่บีบคอคุณจนตาย แต่อย่างจริงจัง ... อย่าทำอย่างนั้น)

การใช้ชื่อแทนฟังก์ชันนั้นใช้ได้ แต่อย่าพยายามเปลี่ยนความหมายของคำที่มีอยู่

มันตกลงที่จะสร้างชื่อแทนของฟังก์ชั่นที่ - ห้องสมุดร่วมกันทำอย่างนั้นตลอดเวลา

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

ดังนั้นในกรณีของคุณให้ทิ้งคำพูด "mininum / maximum" ที่คุณสับสนและสร้างโค้ดของคุณเองที่เข้าใจง่าย

สร้างตัวอย่างของคุณใหม่:

int apply_upper_bound(int x, int y)
{
    return min(x, y);
}


int apply_lower_bound(int x, int y)
{
    return max(x, y)
}

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

ฉันรักคำถามนี้ มาทำลายมันกันเถอะ

1: คุณควรรวมโค้ดหนึ่งบรรทัดไว้หรือไม่

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

นอกจากนี้คุณสามารถทำสิ่งต่าง ๆ มากมายในบรรทัดเดียววันนี้

2: ชื่อ 'Min' และ 'Max' สับสนหรือไม่

ใช่ พวกเขาทั้งหมด! กูรูการเข้ารหัสที่สะอาดจะเปลี่ยนชื่อ "FunctionWhichReturnsTheLargestOfItsParameters" หรืออะไรบางอย่าง โชคดีที่เรามีเอกสารประกอบและ (ถ้าคุณโชคดี) IntelliSenseและความคิดเห็นจะช่วยเราออกมาเพื่อให้ทุกคนที่สับสนในชื่อสามารถอ่านสิ่งที่พวกเขาควรจะทำ

3: คุณควรเปลี่ยนชื่อพวกเขาเป็นอย่างอื่นด้วยตัวคุณเอง

ใช่ไปเลย ตัวอย่างเช่นคุณอาจมี:

class Employee
{
    int NumberOfHolidayDaysIShouldHave(int daysInLue, int maxAllowableHolidayDays)
    {
         // Return the number of days in lue, but keep the value under the max allowable holiday days!
         // Don't use max, you fool!!
         return Math.Max(daysInLue, maxAllowableHolidayDays)
    }
}

มันเพิ่มความหมายและผู้โทรไม่จำเป็นต้องหรือต้องการทราบวิธีการคำนวณค่า

4: คุณควรเปลี่ยนชื่อ "นาที" เป็น "ขยาย"

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

// Add x and y, but don't let it go over 255
s = min(x + y, 255);

จากนั้นเมื่อมีคนอ่าน

// Add x and y, but don't let it go over 255
s = max(x + y, 255);

พวกเขารู้ว่าคุณทำผิดพลาด

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

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

แต่เปลี่ยนชื่อที่จะพูดตามที่ได้รับการแนะนำจะดีเพราะมันเห็นได้ชัดว่าไม่สื่อสารความตั้งใจที่ถึงแม้ว่ามันจะเป็นเพียงแค่การตัดcap(x, limit)min

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

หากคุณถูกขอให้ต่ำที่สุดน้อยที่สุดหรือเร็วที่สุดคุณรู้สึกว่า Max เป็นฟังก์ชั่นที่เหมาะสมหรือไม่?

เว้นนาทีและสูงสุดเพียงอย่างเดียว เขียนการทดสอบอย่างน้อยที่สุดคุณจะได้รับการแก้ไขในครั้งที่สอง

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

เพื่อตอบคำถามของคุณ: มีเหตุผลอื่นใดหรือไม่ที่จะทำให้ไม่เหมาะสม? ในโครงการกลุ่มมีอะไรบ้าง มันทำให้รู้สึกว่าคุณต้องการฟังก์ชั่นของคุณเองซึ่งไม่มีปัญหา เพียงให้แน่ใจว่าพวกเขาอยู่ในชั้นผู้ช่วยของคุณและไม่สามารถเรียกได้ง่ายสำหรับผู้อื่นเว้นแต่พวกเขาจะนำเข้า (Joes.Utilities.)

แต่เพื่อที่จะดูปัญหาของคุณอีกครั้งฉันก็จะคิดแทน:

return (input >= 255) ? 255 : input;

คุณสับสนเพราะคุณกำลังพยายามใช้ตรรกะสมองกับฟังก์ชั่นขั้นต่ำ / สูงสุดเหล่านี้ แทนที่จะพูดเป็นภาษาอังกฤษ เป็นอย่างอื่นifinputgreater than or equal to 255 then return 255returninput

ซึ่งเป็น:

if (input >= 255) {
   255 
} else {
   input
}

ความคิดเห็นของฉัน. คุณจะใช้ฟังก์ชัน max \ min ด้วยเหตุผลที่ไม่ถูกต้องความเร็วของสิ่งเหล่านี้เล็กน้อยมาก ทำในสิ่งที่สมเหตุสมผล

ในขณะที่ฉันเข้าใจปัญหาของคุณฉันก็ลังเลที่จะทำเช่นนี้ มันจะเป็นการดีกว่าถ้าคุณเจาะหัวกะโหลกของคุณในสิ่งที่ min () และ max () ทำ

โปรแกรมเมอร์ส่วนใหญ่รู้ว่าฟังก์ชั่นขั้นต่ำ () และ max () ทำอะไร - แม้ว่าบางครั้งพวกเขาก็ต้องต่อสู้กับสัญชาตญาณที่จะใช้ในเวลาใดก็ตาม ถ้าฉันอ่านโปรแกรมและดู max (x, y) ฉันจะรู้ทันทีว่ามันทำอะไร หากคุณสร้างฟังก์ชัน "นามแฝง" ของคุณเองใครก็ตามที่อ่านรหัสของคุณจะไม่ทราบว่าชื่อแทนนี้ทำอะไร พวกเขาต้องหาฟังก์ชั่นของคุณ มันเป็นการหยุดการไหลของการอ่านโดยไม่จำเป็นและบังคับให้ผู้อ่านต้องคิดเพิ่มเติมเพื่อทำความเข้าใจโปรแกรมของคุณ

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

เมื่อคุณนามแฝงฟังก์ชั่นเพราะชื่อปะทะกับสัญชาตญาณของคุณ ... นี่เป็นกรณีเดียวที่เป็นปัญหาหรือไม่ หรือคุณจะใช้นามแฝงฟังก์ชั่นอื่น ๆ ? บางทีคุณอาจสับสนโดย "อ่าน" และคิดว่ามันง่ายกว่าที่จะเป็น "ยอมรับ" คุณเปลี่ยน "ผนวก" เป็น "StringTogether", "รอบ" เป็น "DropDecimals" ฯลฯ ฯลฯ นำสิ่งนี้ไปสู่ความน่าขันสุดขีด และโปรแกรมของคุณจะเข้าใจยาก

แน่นอนเมื่อหลายปีก่อนฉันทำงานกับโปรแกรมเมอร์ที่ไม่ชอบเครื่องหมายวรรคตอนทั้งหมดใน C ดังนั้นเขาจึงเขียนมาโครเพื่อให้เขาเขียน "THEN" แทนที่จะเป็น "{" และ "END-IF" แทนที่จะเป็น "}" และอื่น ๆ อีกมากมายเช่นการแทนที่ ดังนั้นเมื่อคุณพยายามอ่านโปรแกรมของเขามันก็ไม่ได้ดูเหมือน C อีกต่อไปเหมือนว่าต้องเรียนรู้ภาษาใหม่ทั้งหมด ฉันจำไม่ได้ว่าตอนนี้แปลว่า "และ" เป็น "&" หรือ "&&" - และนั่นคือประเด็น คุณบ่อนทำลายคนที่ลงทุนในการเรียนรู้ภาษาและห้องสมุด

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

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

คุณไม่ใช่คนเดียวที่มีปัญหากับ min และ max แต่ฉันยังเห็นโซลูชันทั่วไปที่ใช้งานได้ดีในทุกโดเมน ฉันคิดว่าปัญหาหนึ่งในการตั้งชื่อฟังก์ชั่นเหล่านี้คือข้อโต้แย้งทั้งสองนั้นมีความหมายเชิงตรรกะที่แตกต่างกัน แต่มีการนำเสนอเป็นความหมายเดียวกัน

หากภาษาของคุณอนุญาตคุณสามารถลองได้

return  calculatedDiscount.ButNoMoreThen(maxAllowedDiscount)

return  CDsInStocked.ButNoMoreThen(CasesInStock)

เลขที่

คุณไม่ได้เขียนผ้าคลุมไหล่ของคุณ ชื่อของสิ่งห่อหุ้มเหล่านั้นไม่สำคัญมากนัก

สิ่งที่คุณพยายามทำคือรหัสที่ทำให้งงงวย คุณกำลังคิดค้นเลเยอร์พิเศษซึ่งให้บริการ 2 วัตถุประสงค์:

1. คนอื่นไม่เข้าใจรหัสของคุณ
2. คุณไม่เคยเรียนรู้ที่จะเข้าใจรหัสของคนอื่น

ด้วยการซ่อนสิ่งที่คุณไม่พอใจคุณจะทำร้ายรหัสของคุณตอนนี้และตัวคุณเองในอนาคตเท่านั้น คุณไม่สามารถเติบโตได้ด้วยการอยู่ในเขตความสะดวกสบายของคุณ สิ่งที่คุณต้องการคือการเรียนรู้วิธีการminและการmaxทำงาน

มันใช้ได้และไม่ใช่การขัดจังหวะการใช้ Min, Max เพื่อบังเกิดใหม่ สิ่งนี้ทำได้โดยใช้:

• พื้น () และเพดาน ()
• ยึด จำกัด ขอบเขต
• และแน่นอน mod ด้วยคำสั่งตัดทอนสูง

ในเฟิร์มแวร์มันย้อนกลับไปไกลกว่า MMX ซึ่งมีกราฟิก 3D ที่ทันสมัยมาก่อนซึ่งอาศัยส่วนขยายนี้

การแทนที่ฟังก์ชั่นมาตรฐานอุตสาหกรรมแม้ในพื้นที่จะทำให้ฉันกังวลชื่ออนุพันธ์อาจดีกว่า นักเรียน C ++ อาจทำงานหนักเกินไปสำหรับชั้นเรียนที่คลุมเครือ

ก็ปรับในบางกรณี แต่ไม่ได้ในตัวอย่างของคุณเพราะมีวิธีที่ดีกว่ามากที่จะคำมัน
saturate, clamp, clipฯลฯ

ฉันต้องการสร้างฟังก์ชันทั่วไปชื่อ 'bounded'

//Assumes lower_bound <= upper_bound
template <typename T>
T bounded(T value, T lower_bound, T upper_bound){
    if (value < lower_bound)
        return lower_bound;
    if (value > upper_bound)
        return upper_bound;
    return value;
}

//Checks an upper (by default) or lower bound
template <typename T>
T bounded(T value, T bound, bool is_upper_bound = true){
    if (is_upper_bound){
        if (value > bound)
            return bound;
    }
    else {
        if (value < bound)
            return bound;
    }
    return value;
}

หรือด้วยการใช้ 'นาที' และ 'สูงสุด'

//Assumes lower_bound <= upper_bound
template <typename T>
T bounded(T value, T lower_bound, T upper_bound){
    return max(min(value, upper_bound), lower_bound);
}

//Checks an upper (by default) or lower bound
template <typename T>
T bounded(T value, T bound, bool is_upper_bound = true){
    if (is_upper_bound)
        return min(value, bound);
    else
        return max(value, bound);
}

สิ่งที่เกี่ยวกับการเรียกฟังก์ชั่นของคุณ:

atmost(x,255): ส่งคืนค่าต่ำสุดของ x หรือ 255 มากที่สุด

atleast(10,x): ส่งคืนค่าที่สูงกว่าของ x หรืออย่างน้อย 10

min(x+y, MAX_VALUE); จะมีความหมายมากกว่านั้น myCustomFunction(x, y);

ดังนั้นคำตอบคือใช่มันไม่สามารถมองเห็นได้ มันทำหน้าที่เป็นเพียงนามแฝงในภาษาสมองของคุณ