小编msk*_*her的帖子

我有以下函数应该返回平均值l1 - l7.但是,它似乎只返回一个整数.为什么这样做,如何让它返回一个舍入为2位小数的浮点数？

片段:

int lab_avg(int l1,int l2,int l3,int l4,int l5,int l6,int l7) {
    float ttl;
    ttl = l1 + l2 +l3 +l4 +l5 +l6 +l7;
    return ttl / 7.0; 
}

在IE6中,HTML如下:

<div id="topmenu">
    <ul>    
        <li>num 1</li>
        <li>num 2</li>
    </ul>
    <div id="rightItem">Hello World</div>
</div>

CSS如下:

#rightItem {
    cursor: pointer;
    float: right;
    clear: none;
    height: 100%;
    width: 340px;
}

#topmenu {
    margin: 0 auto;
    text-align: left;
    width: 960px;
    height: 41px;
}

它在除IE6之外的所有浏览器中将itemRight浮动到同一行(第一个UL然后是rightItem)的右侧.在IE6中,它是清除并向右浮动.我如何修复IE6？

我正在学习C++,但是我遇到了一个我不理解的错误.

这是我的源代码,包括评论(我正在学习的个人参考.)

#include "stdafx.h"
#include <iostream>

using namespace std;

int main()
{
 float h; //a float stands for floating point variable and can hold a number that is a fraction. I.E. 8.5
 double j; //a double can hold larger fractional numbers. I.E. 8.24525234
 char f; // char stands for character and can hold only one character (converts to ASCII, behind scenes).
 f = '$';  //char can hold any common symbol, numbers, uppercase, lowerver, and special characters.
 h = "8.5";
 j …

我正在尝试一个可以找到毕达哥拉斯的简单F#脚本.

这是代码:

open System

let FindHypotenuse a b =
    Math.Sqrt(Math.Pow(a, 2.0) + Math.Pow(b, 2.0))

FindHypotenuse(2.0, 3.0)

有什么建议？

我需要一些帮助,试图在IE中正确显示浮动.我试图将它[箭头]向右浮动后IE想要添加换行符...

我想它显示像Firefox(右),它们都适合一行,但我似乎无法弄清楚如何...

干杯.

background-image: url( '/img/arrow_down.gif' ); 
background-repeat: no-repeat;
height: 8px;
width: 15px;
display: inline;
float: right;

我们有一个测量数据处理应用程序,目前所有数据都保存为C++ float,这意味着我们的x86/Windows平台上有32bit/4byte.(32位Windows应用程序).

由于精度正在成为一个问题,因此一直在讨论转向另一种数据类型.目前讨论的选项是切换到double(8byte)或在__int64(8byte)之上实现固定的十进制类型.

__int64甚至讨论使用固定十进制解决方案作为基础类型的原因是有人声称double性能(仍)明显比处理floats 差,并且我们可能会看到使用本机整数类型存储数字的显着性能优势.(请注意,我们确实可以使用固定的小数精度,尽管代码显然会变得更复杂.)

显然我们最终需要进行基准测试,但我想问一下,加倍的声明是否会让现代处理器看到真相？我想对于大型阵列双打可能会使缓存命中更加浮动,但是否则我真的看不出它们在性能方面会有什么不同？

我的代码中有一个常量pi:

const float PI = acos(-1);

将它声明为双倍会更好吗？对该网站上另一个问题的回答称浮点运算并不完全准确,我希望常数是准确的.

任何人都可以详细解释这个log2函数是如何工作的:

inline float fast_log2 (float val)
{
   int * const    exp_ptr = reinterpret_cast <int *> (&val);
   int            x = *exp_ptr;
   const int      log_2 = ((x >> 23) & 255) - 128;
   x &= ~(255 << 23);
   x += 127 << 23;
   *exp_ptr = x;

   val = ((-1.0f/3) * val + 2) * val - 2.0f/3;   // (1)

   return (val + log_2);
} 

我需要将float转换为字符串,但是要转换为小数点后六位.如何在不将其转换为带有E表示法的字符串的情况下执行此类任务？

我打算在项目中使用多个名称索引字典.我的第一选择是使用一个string键,它只是我Value元素的Name属性.

但是,即使它们访问不同类型,这也会使字典键完全相同:

private Dictionary<string, Foo> myFoos;
private Dictionary<string, Bar> myBars;

myFoos[bar.Name];  // shouldn't be able to do this!

我希望密钥彼此不兼容,使它们无法互相混淆:

private Dictionary<FooName, Foo> myFoos;
private Dictionary<BarName, Bar> myBars;

由于*Name为每种Value类型创建一个类是过度的,我创建了一个Name<T>类:

public struct Name<T>
{
    public string Name;

    // for convenience, could be explicit instead
    static implicit operator string(Name<T> name)
    {
        return name.Name;
    }
}

这会给我

private Dictionary<Name<Foo>, Foo> myFoos;
private Dictionary<Name<Bar>, Bar> myBars;

然后我可以存储Name<Foo>实例而不是字符串.

这看起来有点笨拙,但这是迄今为止我提出的最好的 - 有关如何做得更好的任何建议吗？
这是误导,还是很棒？