C＃decimal是啥类型以及它的作用

Posted 2023-04-18

在C#里decimal表示 128 位数据类型，与double相比，decimal 类型具有更高的精度和更小的范围，适合于财务和货币计算。

Decimal数据类型可以在Visual Studio编辑器中使用，只要在一个浮点类型的值后加一个大写或小写的M，则编辑器会认为这个浮点类型的值是一个Decimal类型。

这种128位高精度十进制数表示法通常用在财务计算中。要注意的是，在.NET环境中，计算该类型的值会有性能上的损失，因为它不是基本类型。

扩展资料：

相关的类型转换：

1、整型将被隐式转换为decimal类型：计算结果为decimal。 可以使用整数文本初始化十进制变量而不使用后缀，如下所示：decimal myMoney = 300;

2、在浮点型和 decimal 类型之间不存在隐式转换：必须使用强制转换以在这两个类型之间转换。例如：decimal myMoney = 99.9m；double x = (double)myMoney；myMoney = (decimal)x。

3、还可以在同一表达式中混合使用 decimal 和数值整型。但是，不进行强制转换就混合使用 decimal 和浮点型将导致编译错误。

参考资料来源：百度百科-c#

参考资料来源：百度百科-Decimal

参考技术A decimal在sql server里是精确值类型，精度38；
在C#里是表示 128 位数据类型。double相比，decimal 类型具有更高的精度和更小的范围，它适合于财务和货币计算。

decimal:
有效位：±1.0 × 10(-28次方) 到 ±7.9 × 10(28次方)
精度：28 到 29 位
double:
有效位：±5.0 × 10(-324次方) 到 ±1.7 × 10(308次方)
精度：15 到 16 位 参考技术B decimal 关键字表示 128 位数据类型。同浮点型相比，decimal 类型具有更高的精度和更小的范围，这使它适合于财务和货币计算。decimal 类型的大致范围和精度如下表所示。 参考技术C Decimal 数据类型只能在 Variant中使用，也就是说，不能声明一变量为 Decimal 的类型。不过可用 Cdec 函数，创建一个子类型为 Decimal 的Variant。

C / C ++如何将3维数组存储在内存中以及遍历它的最快方法是啥

【中文标题】C / C ++如何将3维数组存储在内存中以及遍历它的最快方法是啥

【英文标题】：C/C++ How a 3 dimensional array is stored in memory and what is the fastest way to traverse itC / C ++如何将3维数组存储在内存中以及遍历它的最快方法是什么

【发布时间】：2014-02-15 03:43:58

【问题描述】：

我试图了解 3 维数组是如何存储在内存中的，以及 std:vector 的存储方式之间的区别。

这是我理解的存储它们的方式，和 std::vectors 的存储方式相同，不同之处在于它们充分利用了内存块 a[0][0][0] a[0][0][1] a[0][0][2]... a[0][1][0] a[0][1] [1] ... a[1][0][0] a[1][0][1]...

我的目标是找出最有效的遍历和数组方式。

例如，我有数组：

v[1000][500][3];

那么如何更高效地遍历呢？

for(i = 0; i < 1000; i++)

    for(j = 0; j < 500; j++)
    
       for(k = 0; k < 3; ++k)
       
           //some operation
       

    

或者将数组声明为更有效；

v[3][500][1000]

并遍历为

for(i = 0; i

是否有任何 CL 工具可以可视化数组的存储方式？

【问题讨论】：

3D 矢量是什么意思？

3维a[10][20][30]

这仍然是一个数组。在您的问题中，您区分了 3D 数组和 3D 矢量。

向量是指多个元素存储在一个内存块中。例如在数组中，一个元素存储在一个内存块中，但在一个内存块中的向量中存储多个元素，具体取决于内存块的数据类型和大小。我想知道向量的元素是否以与数组元素相同的顺序存储在内存中，以及遍历它的最有效方法是什么。

请编辑您的问题以说明您的意思。并指定您是否在谈论 std::vector 因为 std::vector 只能是一维。

【参考方案1】：

你说得对，内存中的数组表示值是连续的。所以初始化为 0 的 int v[2][2][2] 看起来像：

[[[0, 0], [0, 0]], [[0, 0], [0, 0]]]

就性能而言，您希望尽可能接近地访问数据以避免数据缓存未命中，因此首先迭代最外层维度是一件好事，因为它们彼此相邻。

在您的第一个示例中可能发生的事情是编译器可能会优化内部循环（如果满足正确的条件）并展开它，这样您就可以通过跳过分支来节省一些时间。

由于您的两个示例都已经以正确的方式迭代，我会说对其进行分析，看看哪个更快。

---

std::vector 还将其元素连续存储在内存中，但由于它是一维的，因此默认情况下应用局部性（前提是您不是随机迭代）。向量的好处是它们可以增长而数组不能（无论如何都是自动的）。

【参考方案2】：

当内存地址是连续的（例如，编译时间数组a[][][]），遍历多维数组最有效的方法是使用a pointer。 a[i][j][k] 实际上是 &a[0][0][0]+(i*j*k + j*k + k)。因此，将指针p初始化为起始地址，然后调用*(p++)

int main() 
    int a[2][3]=1,2,3,4,5,6;
    int *p = &a[0][0];
    for( int i=0; i<6; ++i )
        cout<<*(p++)<<endl;
    
    return 0;

【讨论】：

而声明v[3][500][1000]就变成了3 * 500 * 1000字节的连续内存。因此，它在记忆中是一样的。两种解决方案的操作次数相同。

【参考方案3】：

使其可见：

#include <iostream>

    int main()
    
        int a[][3] =   0, 1, 2 ,  3, 4, 5  ;
        int* p = reinterpret_cast<int*>(a);
        for(unsigned i = 0; i < 6; ++i) 
            std::cout << *(p + i);
        
        std::cout << std::endl;
        return 0;
    

显示一行主要顺序 - 请参阅：http://en.wikipedia.org/wiki/Row-major_order

有了这个，您应该逐行迭代以利用缓存。在更高维度 N 中，你会得到类似的结果，其中每个元素代表一个维度为 N-1 的数据块