ฉันจะเริ่มต้น float เป็นค่าสูงสุด / นาทีได้อย่างไร

ฉันจะฮาร์ดโค้ดค่าสูงสุดหรือต่ำสุดสัมบูรณ์สำหรับทศนิยมหรือสองเท่าได้อย่างไร ฉันต้องการค้นหาค่าสูงสุด / นาทีของอาร์เรย์โดยเพียงแค่วนซ้ำและจับค่าที่ใหญ่ที่สุด

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

คุณสามารถใช้std::numeric_limitsซึ่งกำหนดไว้<limits>เพื่อค้นหาค่าต่ำสุดหรือสูงสุดของประเภท (ตราบเท่าที่มีความเชี่ยวชาญเฉพาะสำหรับประเภท) คุณยังสามารถใช้เพื่อดึงข้อมูลอินฟินิตี้ (และวางไว้-ด้านหน้าสำหรับอินฟินิตี้เชิงลบ)

#include <limits>

//...

std::numeric_limits<float>::max();
std::numeric_limits<float>::min();
std::numeric_limits<float>::infinity();

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

แน่นอนว่ามีstd::max_elementฟังก์ชันและ min_element (กำหนดไว้ใน<algorithm>) ซึ่งอาจเป็นทางเลือกที่ดีกว่าสำหรับการค้นหาค่าที่ใหญ่ที่สุดหรือน้อยที่สุดในอาร์เรย์

คุณสามารถใช้-FLT_MAX(หรือ-DBL_MAX) สำหรับจำนวนลบขนาดสูงสุดและFLT_MAX(หรือDBL_MAX) สำหรับค่าบวก ค่านี้ให้ช่วงของค่า float (หรือ double) ที่เป็นไปได้

คุณอาจไม่ต้องการใช้FLT_MIN; มันสอดคล้องกับจำนวนบวกที่มีขนาดเล็กที่สุดที่สามารถแทนค่าได้ด้วยค่าลอยไม่ใช่ค่าที่เป็นลบมากที่สุดที่แทนค่าได้ด้วยลูกลอย

FLT_MINและFLT_MAXสอดคล้องกับและstd::numeric_limits<float>::min()std::numeric_limits<float>::max()

ไม่จำเป็นต้องเริ่มต้นให้เล็กที่สุด / ใหญ่ที่สุดเท่าที่จะเป็นไปได้เพื่อค้นหาสิ่งที่เล็กที่สุด / ใหญ่ที่สุดในอาร์เรย์:

double largest = smallest = array[0];
for (int i=1; i<array_size; i++) {
    if (array[i] < smallest)
        smallest = array[i];
    if (array[i] > largest0
        largest= array[i];
}

หรือหากคุณทำมากกว่าหนึ่งครั้ง:

#include <utility>

template <class iter>
std::pair<typename iter::value_type, typename iter::value_type> find_extrema(iter begin, iter end) {
    std::pair<typename iter::value_type, typename iter::value_type> ret;
    ret.first = ret.second = *begin;
    while (++begin != end) {
        if (*begin < ret.first)
           ret.first = *begin;
        if (*begin > ret.second)
           ret.second = *begin;
   }
   return ret;
}

ข้อเสียของการให้โค้ดตัวอย่าง - ฉันเห็นว่ามีคนอื่นแนะนำแนวคิดเดียวกันนี้แล้ว

โปรดทราบว่าแม้ว่ามาตรฐานจะมี min_element และ max_element แต่การใช้สิ่งเหล่านี้จะต้องมีการสแกนข้อมูลสองครั้งซึ่งอาจเป็นปัญหาได้หากอาร์เรย์มีขนาดใหญ่เลย มาตรฐานล่าสุดได้แก้ไขปัญหานี้โดยการเพิ่ม a std::minmax_elementซึ่งทำเช่นเดียวกับfind_extremaข้างต้น (ค้นหาทั้งองค์ประกอบต่ำสุดและสูงสุดในคอลเลกชันในรอบเดียว)

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

unsigned int min_nonzero(std::vector<unsigned int> const &values) { 
    if (vector.size() == 0)
        return 0;
    unsigned int temp = values[0]-1;
    for (int i=1; i<values.size(); i++)
        if (values[i]-1 < temp)
            temp = values[i]-1;
    return temp+1;
}

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

ในการค้นหาอาร์เรย์ขั้นต่ำด้วยตนเองคุณไม่จำเป็นต้องทราบค่าต่ำสุดของ float:

float myFloats[];
...
float minimum = myFloats[0];
for (int i = 0; i < myFloatsSize; ++i)
{
  if (myFloats[i] < minimum)
  {
    minimum = myFloats[i];
  }
}

และรหัสที่คล้ายกันสำหรับค่าสูงสุด

ฉันขอแนะนำให้คุณเริ่มต้นตัวแปร "max and min so far" ของคุณไม่ให้เป็นค่าอนันต์ แต่เป็นตัวเลขแรกในอาร์เรย์