DBL_MAX：double型的最大值
 
DBL_MIN：double型的最小值
 
FLT_MAX：float型的最大值
 
FLT_MIN：float型的最小值
 
1、C语言是一门通用计算机编程语言，应用广泛。C语言的设计目标是提供一种能以简易的方式编译、处理低级存储器、产生少量的机器码以及不需要任何运行环境支持便能运行的编程语言。
 
2、尽管C语言提供了许多低级处理的功能，但仍然保持着良好跨平台的特性，以一个标准规格写出的C语言程序可在许多电脑平台上进行编译，甚至包含一些嵌入式处理器(单片机或称MCU)以及超级电脑等作业平台。
 
3、二十世纪八十年代，为了避免各开发厂商用的C语言语法产生差异，由美国国家标准局为C语言订定了一套完整的国际标准语法，称为ANSI C，作为C语言最初的标准。
 
4、C是高级语言：它把高级语言的基本结构和语句与低级语言的实用性结合起来。C 语言可以像汇编语言一样对位、字节和地址进行操作，而这三者是计算机最基本的工作单元。
 
5、C是结构式语言：结构式语言的显著特点是代码及数据的分隔化，即程序的各个部分除了必要的信息交流外彼此独立。这种结构化方式可使程序层次清晰，便于编码、维护以及调试。C 语言是以函数形式提供给用户的，这些函数可方便的调用，并具有多种循环、条件语句控制程序流向，从而使程序完全结构化。

 
评论
 
# re: 求解：如何获得enum类型中枚举值的数量
 
2009-11-11 20:43
 
OwnWaterloo
 
# re: 求解：如何获得enum类型中枚举值的数量[未登录]
 
2009-11-12 01:47
 
Liu
 
搞不懂你咋有这么变态的需求。
 
sizeof(T)当然是4，就是一个Integer么
 
编译过程中，这些应该直接当作了常量处理吧？所以你上哪里知道有多少常量呢  回复  更多评论
 
# re: 求解：如何获得enum类型中枚举值的数量
 
2009-11-12 09:46
 
codejie
 
@OwnWaterloo
 
悲剧～  回复  更多评论
 
# re: 求解：如何获得enum类型中枚举值的数量
 
2009-11-12 09:47
 
codejie
 
@Liu
 
嗯，我需求就是要知道‘有多少常量’，不是很变态吧。。。。
 
另：
 
为了C，我又买了三本书：C语言，C专家，C陷阱。你看我够勤奋吧～  回复  更多评论
 
# re: 求解：如何获得enum类型中枚举值的数量
 
2009-11-12 10:09
 
溪流
 
enum T
 
{
 
T1 = 0,
 
T2,
 
// ...
 
Tn,
 
T_MAX
 
};
 
读 T_MAX 确定个数  回复  更多评论
 
# re: 求解：如何获得enum类型中枚举值的数量
 
2009-11-12 10:28
 
codejie
 
@溪流
 
嗯，我就是不想定义个T_MAX。。。。嘿嘿。。。  回复  更多评论
 
# re: 求解：如何获得enum类型中枚举值的数量
 
2009-11-12 20:11
 
溪流
 
@codejie
 
那，木有了  回复  更多评论
 
# re: 求解：如何获得enum类型中枚举值的数量[未登录]
 
2009-11-12 20:19
 
codejie
 
@溪流
 
杯具啊～  回复  更多评论
 
# re: 求解：如何获得enum类型中枚举值的数量[未登录]
 
2009-11-13 03:34
 
Liu
 
@codejie
 
有时候我觉得，你是不是勤奋的过头了……  回复  更多评论
 
# re: 求解：如何获得enum类型中枚举值的数量
 
2009-11-13 10:05
 
codejie
 
@Liu
 
哎呀，不想平常的你啊。。。我以为你会说我－－吃了空。。。  回复  更多评论
 
# re: 求解：如何获得enum类型中枚举值的数量
 
2010-05-22 23:27
 
Freeway
 
This works in C#:
 
enum ae
 
{
 
aa,
 
bb
 
}
 
public static void enumTest()
 
{
 
var el = Enum.GetNames(typeof(ae)).ToList();
 
el.ForEach(e => Console.WriteLine(e));
 
}
 
Hope this could help in CPP.  回复  更多评论
 
# re: 求解：如何获得enum类型中枚举值的数量
 
2010-05-24 12:33
 
codejie
 
@Freeway
 
CPP这样应该不行，没有对应的函数。。。
 
(CPPBLOG.COM应该rollback过了，我前面的回复没有了。。。)  回复  更多评论
 
# re: 求解：如何获得enum类型中枚举值的数量
 
2013-02-27 15:33
 
cnbt
 
得到一个总数循环判断,,,  回复  更多评论
 
# re: 求解：如何获得enum类型中枚举值的数量[未登录]
 
2013-02-27 20:14
 
codejie
 
@cnbt
 
有了总数,还循环个毛毛啊...  回复  更多评论
 
# re: 求解：如何获得enum类型中枚举值的数量
 
2013-03-01 00:14
 
溪流
 
@codejie
 
哈哈：)  回复  更多评论

 
dyp..
 
121
 
根据标准设置的颜色是什么？
 
回答C++ 11和C++ 14标准的引用:
 
[expr.static.cast]/10
 
可以将整数或枚举类型的值显式转换为枚举类型.如果原始值在枚举值(7.2)的范围内,则该值不变.否则,结果值未指定(可能不在该范围内).
 
让我们查看枚举值的范围:[dcl.enum]/7
 
对于其基础类型是固定的枚举,枚举的值是基础类型的值.
 
在CWG 1766之前(C++ 11,C++ 14)
 
因此,对于data[0] == 100,指定结果值(*),并且不涉及未定义行为(UB).更一般地说,当您从基础类型转换为枚举类型时,没有任何值data[0]可以导致UB static_cast.
 
在CWG 1766(C++ 17)之后,
 
参见CWG缺陷1766.[expr.static.cast] p10段已得到加强,因此如果将枚举的可表示范围之外的值强制转换为枚举类型,则现在可以调用UB.这仍然不适用于问题中的场景,因为它data[0]是枚举的基础类型(见上文).
 
请注意,CWG 1766被认为是标准中的缺陷,因此编译器实现者可以将其应用于其C++ 11和C++ 14编译模式.
 
(*)char必须至少为8位宽,但不是必须的unsigned.可存储的最大值至少127应符合C99标准的附录E.
 
与[expr]/4比较
 
如果在评估表达式期间,结果未在数学上定义或未在其类型的可表示值范围内,则行为未定义.
 
在CWG 1766之前,转换整数类型 - >枚举类型可以产生未指定的值.问题是:未指定的值是否可以超出其类型的可表示值？我相信答案是否定的 - 如果答案是肯定的,那么在"此操作产生未指定的值"和"此操作具有未定义的行为"之间对签名类型的操作所获得的保证不会有任何差异.
 
因此,之前CWG 1766,甚至static_cast(10000)会不会调用UB; 但是在CWG 1766之后,它确实调用了UB.
 
现在,switch声明:
 
[stmt.switch]/2
 
条件应为整数类型,枚举类型或类类型.[...] 执行整体促销.
 
[conv.prom/4
 
其基础类型为固定(7.2)的未作用域枚举类型的prvalue可以转换为其基础类型的prvalue.此外,如果可以对其基础类型应用整数提升,则其基础类型固定的无范围枚举类型的prvalue也可以转换为提升的基础类型的prvalue.
 
注意:带有enum-base的作用域枚举的基础类型是int.对于未作用域的枚举,底层类型是实现定义的,但不能大于intif是否int可以包含所有枚举器的值.
 
对于无范围的枚举,这会将我们引向/ 1
 
以外的整数类型的prvalue bool,char16_t,char32_t,或wchar_t,其整数转换秩(4.13)小于的秩int可以被转换成类型的prvalue int如果int可以表示源类型的所有值; 否则,源prvalue可以转换为类型的prvalue unsigned int.
 
在没有范围的枚举的情况下,我们将在int这里处理s.对于作用域枚举(enum class和enum struct),不适用整数提升.无论如何,积分促销也不会导致UB,因为存储的值在基础类型的范围内并且在范围内int.
 
[stmt.switch]/5
 
当switch被执行的语句,其条件评价,并与每一种情况下恒定比较.如果其中一个case常量等于条件的值,则将控制权传递给匹配case标签后面的语句.如果没有case常量匹配条件,并且如果有default标签,则控制传递到标签标记的语句default.
 
该default标签应被击中.
 
注意:可以再看一下比较运算符,但它没有在引用的"比较"中明确使用.事实上,在我们的案例中,没有任何暗示它会为范围或未范围的枚举引入UB.
 
作为奖励,该标准是否对此有任何保证,但是用简单的枚举？
 
是否enum作用范围在这里没有任何区别.但是,无论底层类型是否固定,它确实有所不同.完整的[decl.enum]/7是:
 
对于其基础类型是固定的枚举,枚举的值是基础类型的值.否则,对于枚举,其中e min是最小的枚举数且e max是最大的,枚举的值是b min到b max范围内的值,定义如下:K设为12的补码表示和0a一个补码或符号幅度表示.b max是大于或等于max(| e min | - K,| e max |)并且等于2 M -1的最小值,其中M是非负整数.如果emin是非负的,则b min为零,否则为- (bmax+).K
 
我们来看看下面的枚举:
 
enum ColorUnfixed /* no fixed underlying type */
 
{
 
red = 0x1,
 
yellow = 0x2
 
}
 
请注意,我们无法将其定义为作用域枚举,因为所有作用域枚举都具有固定的基础类型.
 
幸运的是,ColorUnfixed最小的枚举器是red = 0x1,所以max(| e min | - K,| e max |)等于| e max |无论如何,这是yellow = 0x2.大于或等于的最小值2,对于正整数,等于2 M -1M是3(2 2 -1).(我认为目的是允许范围以1位步进扩展.)接着是b max是3和bmin是0.
 
因此,100将在CWG 1766之前产生未指定的值ColorUnfixed,并且static_cast在CWG 1766之后产生未定义的行为.
 
基础类型是固定的,因此枚举值的范围(§7.2[dcl.enum] p7)是"基础类型的值".100肯定是`char`的值,所以"如果原始值在枚举值(7.2)的范围内,则值不变." 适用. (3认同)
 
我不得不寻找"UB"的意思.('未定义的行为')问题没有提到未定义行为的可能性; 所以我没想到你可能会谈论这个. (2认同)
 
@karadoc我在第一次出现时添加了一个链接. (2认同)

 
如果我想要列表中的最大值，我可以写max(List)，但是如果我还需要最大值的索引呢？
 
我可以这样写：
 
maximum=0
 
for i,value in enumerate(List):
 
if value>maximum:
 
maximum=value
 
index=i
 
但这对我来说看起来很乏味。
 
如果我写：
 
List.index(max(List))
 
然后它将迭代列表两次。
 
有没有更好的办法？
 
你是什么意思"它会通过两次列表"？ List.index(max(List))适合我。
 
@mwc：它将迭代列表一次以确定最大值，然后再次迭代它以查找该值的索引。
 
如果有重复的最大值，list.index()会不会有问题？
 
@LoganYang是的，可能有两个具有相同值的项目。
 
如果订单不重要，你可以做一些像List.sort()[ - 1]
 
我认为接受的答案很好，但为什么不明确地这样做呢？我觉得更多的人会理解你的代码，这与PEP 8一致：
 
max_value = max(my_list)
 
max_index = my_list.index(max_value)
 
这种方法也比接受的答案快三倍：
 
import random
 
from datetime import datetime
 
import operator
 
def explicit(l):
 
max_val = max(l)
 
max_idx = l.index(max_val)
 
return max_idx, max_val
 
def implicit(l):
 
max_idx, max_val = max(enumerate(l), key=operator.itemgetter(1))
 
return max_idx, max_val
 
if __name__ =="__main__":
 
from timeit import Timer
 
t = Timer("explicit(l)","from __main__ import explicit, implicit;"
 
"import random; import operator;"
 
"l = [random.random() for _ in xrange(100)]")
 
print"Explicit: %.2f usec/pass" % (1000000 * t.timeit(number=100000)/100000)
 
t = Timer("implicit(l)","from __main__ import explicit, implicit;"
 
"import random; import operator;"
 
"l = [random.random() for _ in xrange(100)]")
 
print"Implicit: %.2f usec/pass" % (1000000 * t.timeit(number=100000)/100000)
 
在我的电脑中运行的结果：
 
Explicit: 8.07 usec/pass
 
Implicit: 22.86 usec/pass
 
其他套装：
 
Explicit: 6.80 usec/pass
 
Implicit: 19.01 usec/pass
 
没想到它会更快。即使我用"l = [random.random()for _ in xrange(10000000)] + [2]"替换l也更快，这保证了最后一个元素是最大的。
 
@ Sunny88：对于一个简单的数字列表，简单的方法更快。如果您在这种情况下表现出色，我建议使用numpy.argmax()，这在我的机器上要快30倍。如果列表包含比单纯数字更复杂的对象，我的答案中的方法可以变得更快。该方法的另一个优点是它可以用于任意迭代器，而不仅仅用于列表。
 
@ Sven-Marnach如果我必须首先将我的列表转换为numpy数组，那么numpy会更快吗？简单的例子[0,1,0]会更快吗？
 
@Sven-Marnach我刚刚检查过。 numpy.argmax是迄今为止最慢的方法，如果数组包含字符串而不是浮点数或整数，则它会给出错误的答案。
 
如果有重复的最大值，list.index()会不会有问题？
 
@LoganYang我不这么认为，当有多个最大值时，max()仅返回第一个(这是Python 3保证的)，list.index()也返回第一个
 
有很多选择，例如：
 
import operator
 
index, value = max(enumerate(my_list), key=operator.itemgetter(1))
 
啊，我在其他地方看过这个，但我认为它只返回一个值，而不是一个元组。
 
@ Sunny88：key函数仅用于决定哪个元素是最大的。元素不会改变。
 
@SvenMarnach为什么不用key=lambda e: e[1]来避免导入？
 
@lifebalance使用itemgetter()更快，避免导入不是值得追求的目标。在某些情况下，避免外部依赖性是值得的，但从标准库导入是不成问题的。
 
这个答案比@Escualo快33倍，假设列表非常大，假设它已经是一个np.array()。我不得不拒绝测试运行次数，因为测试正在查看10000000个元素而不仅仅是100个元素。
 
import random
 
from datetime import datetime
 
import operator
 
import numpy as np
 
def explicit(l):
 
max_val = max(l)
 
max_idx = l.index(max_val)
 
return max_idx, max_val
 
def implicit(l):
 
max_idx, max_val = max(enumerate(l), key=operator.itemgetter(1))
 
return max_idx, max_val
 
def npmax(l):
 
max_idx = np.argmax(l)
 
max_val = l[max_idx]
 
return (max_idx, max_val)
 
if __name__ =="__main__":
 
from timeit import Timer
 
t = Timer("npmax(l)","from __main__ import explicit, implicit, npmax;"
 
"import random; import operator; import numpy as np;"
 
"l = np.array([random.random() for _ in xrange(10000000)])")
 
print"Npmax: %.2f msec/pass" % (1000  * t.timeit(number=10)/10 )
 
t = Timer("explicit(l)","from __main__ import explicit, implicit;"
 
"import random; import operator;"
 
"l = [random.random() for _ in xrange(10000000)]")
 
print"Explicit: %.2f msec/pass" % (1000  * t.timeit(number=10)/10 )
 
t = Timer("implicit(l)","from __main__ import explicit, implicit;"
 
"import random; import operator;"
 
"l = [random.random() for _ in xrange(10000000)]")
 
print"Implicit: %.2f msec/pass" % (1000  * t.timeit(number=10)/10 )
 
我的电脑上的结果：
 
Npmax: 8.78 msec/pass
 
Explicit: 290.01 msec/pass
 
Implicit: 790.27 msec/pass
 
只是为了澄清：加速只是由于numpy C实现与纯python相比？或者有一种方法可以使用纯python来改进@Escualo的答案？
 
不我知道它有效
 
如果想要使用python 3.6，可以执行以下操作："l = np.array([random.random()for _ in range(10000000)])")print(f"Npmax：{(1000 * t。 timeit(number = 10)/ 10)：5.2f} msec / pass")
 
这是在2.7
 
嗯，numpy.argmax的速度看起来很惊人，直到你让它处理一个标准的python列表。然后速度介于显式和隐式版本之间。我猜np.array不只是创建一个列表，但它会在其中保存一些额外的信息 - 例如最小值和最大值(只是一个假设)。
 
使用Python的内置库，它非常简单：
 
a = [2, 9, -10, 5, 18, 9]
 
max(xrange(len(a)), key = lambda x: a[x])
 
这告诉max使用自定义函数lambda x: a[x]查找列表[0, 1, 2, ..., len(a)]中的最大数字，其中0实际上是2，1实际上是9等。
 
在Python 3中，没有xrange，如果你想编写将同时运行Python 2和Python 3的代码，你应该使用range()。
 
max([(v,i) for i,v in enumerate(my_list)])
 
这是更好的，因为你可以使它适用于除元组之外的其他东西。
 
这究竟是如何工作的？你能打破这个过程吗？
 
嗨@ clabe45，它将my_list转换为元组列表(v，i)，其中v是我的列表中的每个项目，i是对应的索引，然后它获得具有最大值的元组(及其相关索引)
 
谢谢，你可以在答案中发帖吗？ max如何知道在计算最大值时只考虑每个元组(v)的第一项？
 
@ clabe45可能这个回复来得太晚了，但现在遇到这个帖子的其他人(比如我)，这里：stackoverflow.com/questions/18296755/是一个解释。不是这一行："默认情况下，max会比较第一个索引的项目，如果第一个索引相同则比较第二个索引。"所以我试了一下list：l = [1,1,1]然后是max([(v，i)代表i，v代表枚举(l)])它给了我不是第一个但是最后一个一：(1,2)结果。我希望它解释:)
 
@AnupamJain现在有意义，谢谢！
 
我建议一个非常简单的方法：
 
import numpy as np
 
l = [10, 22, 8, 8, 11]
 
print(np.argmax(l))
 
print(np.argmin(l))
 
希望能帮助到你。
 
max([(value,index) for index,value in enumerate(your_list)]) #if maximum value is present more than once in your list then this will return index of the last occurrence
 
如果当前最大值不止一次并且您想要获得所有指数，
 
max_value = max(your_list)
 
maxIndexList = [index for index,value in enumerate(your_list) if value==max(your_list)]
 
对。我几乎发布了一个答案，但后来我看到你已经在列表理解一行中使用了相同的逻辑解决方案。
 
抱歉恢复这个线程，但我认为我的方法值得添加。
 
此示例中的列表名称'list'
 
list.sort()
 
print(list[-1])
 
这将打印列表中的最高值容易！
 
list.sort()按ASCII表中项目的值对列表进行排序，因此可以有效地将列表从最低到最高排序。然后我使用print(list[-1])打印列表中的最后一个值(这将是最大的数字)。
 
希望这可以帮助！
 
我们不能这样得到索引
 
也许你还需要一个排序列表？
 
试试这个：
 
your_list = [13, 352, 2553, 0.5, 89, 0.4]
 
sorted_list = sorted(your_list)
 
index_of_higher_value = your_list.index(sorted_list[-1])
 
尝试格式化代码以使其更具可读性
 
1.排序具有更高的时间复杂度。 2. sorted_list没有索引而是值，所以它不起作用。
 
以下是使用Python内置函数的问题的完整解决方案：
 
# Create the List
 
numbers = input("Enter the elements of the list. Separate each value with a comma. Do not put a comma at the end.
 
").split(",")
 
# Convert the elements in the list (treated as strings) to integers
 
numberL = [int(element) for element in numbers]
 
# Loop through the list with a for-loop
 
for elements in numberL:
 
maxEle = max(numberL)
 
indexMax = numberL.index(maxEle)
 
print(maxEle)
 
print(indexMax)