c++ int 24 - 24位整数数据类型

z9ju0rcb  于 2022-11-19  发布在  其他
关注(0)|答案(6)|浏览(459)

C++中有24位基本整型数据类型吗？
如果没有，是否可以创建一个类int24（，uint24）？
其目的可能是：

  • 操作24位格式的声音文件
  • 无α通道操作位图数据
c++

6条答案

按热度按时间
ncgqoxb0

ncgqoxb01#

根据需要，我将使用位域。

  1. struct int24{
  2.     unsigned int data : 24;
  3. };

或者，如果分离更容易，则仅使用3个字节（字符）。
顺便说一句，你在问题中提到的两个用例通常都使用32位整数。在音频处理的情况下，你通常会转换为32位整数（或浮点数，最好是，以防止溢出的情况下，你会得到与定点或整数数学），当加载块的音频，因为你不会有整个文件在内存中一次。
对于图像数据，人们倾向于使用32位整数，而忽略alpha 8位，或者如果你要处理一个紧密压缩的格式，你可能更好地把它们作为字符指针来处理，因为你会把所有的通道分开。这将是一个性能/内存的权衡，因为写一个int通常比分别写三个字符快;但是它将占用多25%内存。
像这样打包结构体是编译器特定的。但是，在Visual Studio中，您可以执行以下操作使结构体正好为24位。

  1. #pragma pack(push, 1)
  2. struct int24{
  3.     unsigned int data : 24;
  4. };
  5. #pragma pack(pop)
赞(0）分享  回复(0）举报  2022-11-19
6ie5vjzr

6ie5vjzr2#

我写这个是为了帮助我进行音频操作。它不是最快的，但对我很有效：）

  1. const int INT24_MAX = 8388607;
  3. class Int24
  4. {
  5. protected:
  6.     unsigned char m_Internal[3];
  7. public:
  8.     Int24()
  9.     {
  10.     }
  12.     Int24( const int val )
  13.     {
  14.         *this   = val;
  15.     }
  17.     Int24( const Int24& val )
  18.     {
  19.         *this   = val;
  20.     }
  22.     operator int() const
  23.     {
  24.         if ( m_Internal[2] & 0x80 ) // Is this a negative?  Then we need to siingn extend.
  25.         {
  26.             return (0xff << 24) | (m_Internal[2] << 16) | (m_Internal[1] << 8) | (m_Internal[0] << 0);
  27.         }
  28.         else
  29.         {
  30.             return (m_Internal[2] << 16) | (m_Internal[1] << 8) | (m_Internal[0] << 0);
  31.         }
  32.     }
  34.     operator float() const
  35.     {
  36.         return (float)this->operator int();
  37.     }
  39.     Int24& operator =( const Int24& input )
  40.     {
  41.         m_Internal[0]   = input.m_Internal[0];
  42.         m_Internal[1]   = input.m_Internal[1];
  43.         m_Internal[2]   = input.m_Internal[2];
  45.         return *this;
  46.     }
  48.     Int24& operator =( const int input )
  49.     {
  50.         m_Internal[0]   = ((unsigned char*)&input)[0];
  51.         m_Internal[1]   = ((unsigned char*)&input)[1];
  52.         m_Internal[2]   = ((unsigned char*)&input)[2];
  54.         return *this;
  55.     }
  57.     /***********************************************/
  59.     Int24 operator +( const Int24& val ) const
  60.     {
  61.         return Int24( (int)*this + (int)val );
  62.     }
  64.     Int24 operator -( const Int24& val ) const
  65.     {
  66.         return Int24( (int)*this - (int)val );
  67.     }
  69.     Int24 operator *( const Int24& val ) const
  70.     {
  71.         return Int24( (int)*this * (int)val );
  72.     }
  74.     Int24 operator /( const Int24& val ) const
  75.     {
  76.         return Int24( (int)*this / (int)val );
  77.     }
  79.     /***********************************************/
  81.     Int24 operator +( const int val ) const
  82.     {
  83.         return Int24( (int)*this + val );
  84.     }
  86.     Int24 operator -( const int val ) const
  87.     {
  88.         return Int24( (int)*this - val );
  89.     }
  91.     Int24 operator *( const int val ) const
  92.     {
  93.         return Int24( (int)*this * val );
  94.     }
  96.     Int24 operator /( const int val ) const
  97.     {
  98.         return Int24( (int)*this / val );
  99.     }
  101.     /***********************************************/
  102.     /***********************************************/
  104.     Int24& operator +=( const Int24& val )
  105.     {
  106.         *this   = *this + val;
  107.         return *this;
  108.     }
  110.     Int24& operator -=( const Int24& val )
  111.     {
  112.         *this   = *this - val;
  113.         return *this;
  114.     }
  116.     Int24& operator *=( const Int24& val )
  117.     {
  118.         *this   = *this * val;
  119.         return *this;
  120.     }
  122.     Int24& operator /=( const Int24& val )
  123.     {
  124.         *this   = *this / val;
  125.         return *this;
  126.     }
  128.     /***********************************************/
  130.     Int24& operator +=( const int val )
  131.     {
  132.         *this   = *this + val;
  133.         return *this;
  134.     }
  136.     Int24& operator -=( const int val )
  137.     {
  138.         *this   = *this - val;
  139.         return *this;
  140.     }
  142.     Int24& operator *=( const int val )
  143.     {
  144.         *this   = *this * val;
  145.         return *this;
  146.     }
  148.     Int24& operator /=( const int val )
  149.     {
  150.         *this   = *this / val;
  151.         return *this;
  152.     }
  154.     /***********************************************/
  155.     /***********************************************/
  157.     Int24 operator >>( const int val ) const
  158.     {
  159.         return Int24( (int)*this >> val );
  160.     }
  162.     Int24 operator <<( const int val ) const
  163.     {
  164.         return Int24( (int)*this << val );
  165.     }
  167.     /***********************************************/
  169.     Int24& operator >>=( const int val )
  170.     {
  171.         *this = *this >> val;
  172.         return *this;
  173.     }
  175.     Int24& operator <<=( const int val )
  176.     {
  177.         *this = *this << val;
  178.         return *this;
  179.     }
  181.     /***********************************************/
  182.     /***********************************************/
  184.     operator bool() const
  185.     {
  186.         return (int)*this != 0;
  187.     }
  189.     bool operator !() const
  190.     {
  191.         return !((int)*this);
  192.     }
  194.     Int24 operator -()
  195.     {
  196.         return Int24( -(int)*this );
  197.     }
  199.     /***********************************************/
  200.     /***********************************************/
  202.     bool operator ==( const Int24& val ) const
  203.     {
  204.         return (int)*this == (int)val;
  205.     }
  207.     bool operator !=( const Int24& val ) const
  208.     {
  209.         return (int)*this != (int)val;
  210.     }
  212.     bool operator >=( const Int24& val ) const
  213.     {
  214.         return (int)*this >= (int)val;
  215.     }
  217.     bool operator <=( const Int24& val ) const
  218.     {
  219.         return (int)*this <= (int)val;
  220.     }
  222.     bool operator >( const Int24& val ) const
  223.     {
  224.         return (int)*this > (int)val;
  225.     }
  227.     bool operator <( const Int24& val ) const
  228.     {
  229.         return (int)*this < (int)val;
  230.     }
  232.     /***********************************************/
  234.     bool operator ==( const int val ) const
  235.     {
  236.         return (int)*this == val;
  237.     }
  239.     bool operator !=( const int val ) const
  240.     {
  241.         return (int)*this != val;
  242.     }
  244.     bool operator >=( const int val ) const
  245.     {
  246.         return (int)*this >= val;
  247.     }
  249.     bool operator <=( const int val ) const
  250.     {
  251.         return (int)*this <= val;
  252.     }
  254.     bool operator >( const int val ) const
  255.     {
  256.         return ((int)*this) > val;
  257.     }
  259.     bool operator <( const int val ) const
  260.     {
  261.         return (int)*this < val;
  262.     }
  264.     /***********************************************/
  265.     /***********************************************/
  266. };
展开查看全部
赞(0）分享  回复(0）举报  2022-11-19
acruukt9

acruukt93#

处理任何小于整数（32位或64位，取决于您的体系结构）的数据都是不理想的。所有较小数据类型（短整型等）的CPU操作都是使用整数运算完成的。必须完成与CPU的转换，这会降低应用程序的速度（即使只是一点点）。
我的建议是：将它们存储为32位（或64位）整数以提高整体速度。当需要进行I/O时，您必须自己进行转换。
至于操作音频数据，有许多库可以为您处理I/O-除非您想开始学习PCM等是如何存储的-以及其他DSP函数。我建议使用其中的一个库。

赞(0）分享  回复(0）举报  2022-11-19
a2mppw5e

a2mppw5e4#

我知道我晚了十年，但你觉得比特集解决方案怎么样？

  1. class i24
  2. {
  3.     std::bitset<24> m_value;
  5. public:
  6.     constexpr i24(int value) noexcept: m_value {static_cast<unsigned long long>(value)} {}
  8.     operator int() const
  9.     {
  10.         constexpr std::uint32_t negative_mask = (0xff << 24);
  11.         return (m_value[23] ? negative_mask : 0) | m_value.to_ulong();
  12.     }
  13. };
赞(0）分享  回复(0）举报  2022-11-19
lyr7nygr

lyr7nygr5#

不-您真正能做的是：

  1. typedef int32_t int24_t;

这有助于使代码/意图更可读/更明显，但不会对范围或存储空间施加任何限制。

赞(0）分享  回复(0）举报  2022-11-19
z4bn682m

z4bn682m6#

最好的方法是创建一个Int24类，并像原始类型一样使用它。
Int24.h

  1. #ifndef INT24_H
  2. #define INT24_H
  4. class Int24
  5. {
  6. public:
  7.     Int24();
  8.     Int24(unsigned long);
  10.     Int24 operator+ (Int24 value);
  11.     Int24 operator* (int value);
  12.     Int24 operator/ (int value);
  14.     void operator= (unsigned long value);
  15.     void operator= (Int24 value);
  16.     operator int() const;
  18.     // Declare prefix and postfix increment operators.
  19.     Int24 &operator++();       // Prefix increment operator.
  20.     Int24 operator++(int);     // Postfix increment operator.
  22.     // Declare prefix and postfix decrement operators.
  23.     Int24 &operator--();       // Prefix decrement operator.
  24.     Int24 operator--(int);     // Postfix decrement operator.
  26.     unsigned long value() const;
  28. private:
  29.     unsigned char mBytes[3] ;
  30. };
  32. #endif // INT24_H

Int24.cpp

  1. #include "Int24.h"
  3. Int24::Int24()
  4. {
  5.     mBytes[0] = 0;
  6.     mBytes[1] = 0;
  7.     mBytes[2] = 0;
  8. }
  10. Int24::Int24(unsigned long value)
  11. {
  12.     mBytes[0] = ( value         & 0xff);
  13.     mBytes[1] = ((value >>  8)  & 0xff);
  14.     mBytes[2] = ((value >> 16 ) & 0xff);
  15. }
  17. Int24 Int24::operator+(Int24 value)
  18. {
  19.     Int24 retVal;
  20.     unsigned long myValue;
  21.     unsigned long addValue;
  23.      myValue = this->mBytes[2];
  24.      myValue <<= 8;
  25.      myValue |= this->mBytes[1];
  26.      myValue <<= 8;
  27.      myValue |= this->mBytes[0];
  29.      addValue = value.mBytes[2];
  30.      addValue <<= 8;
  31.      addValue |= value.mBytes[1];
  32.      addValue <<= 8;
  33.      addValue |= value.mBytes[0];
  35.      myValue += addValue;
  37.      retVal = myValue;
  39.      return retVal;
  40. }
  42. Int24 Int24::operator*(int value)
  43. {
  44.     (*this) = (*this).value() * value;
  45.     return (*this);
  46. }
  48. Int24 Int24::operator/(int value)
  49. {
  50.     (*this) = (*this).value() / value;
  51.     return (*this);
  52. }
  54. void Int24::operator=(unsigned long value)
  55. {
  56.     mBytes[0] = ( value         & 0xff);
  57.     mBytes[1] = ((value >>  8)  & 0xff);
  58.     mBytes[2] = ((value >> 16 ) & 0xff);
  59. }
  61. void Int24::operator=(Int24 value)
  62. {
  63.     mBytes[0] = value.mBytes[0];
  64.     mBytes[1] = value.mBytes[1];
  65.     mBytes[2] = value.mBytes[2];
  66. }
  68. Int24 &Int24::operator++()
  69. {
  70.     (*this) = (*this).value() + 1;
  71.     return *this;
  72. }
  74. Int24 Int24::operator++(int)
  75. {
  76.     Int24 temp = (*this);
  77.     ++(*this);
  78.     return temp;
  79. }
  81. Int24 &Int24::operator--()
  82. {
  83.     (*this) = (*this).value() - 1;
  84.     return *this;
  85. }
  87. Int24 Int24::operator--(int)
  88. {
  89.     Int24 temp = (*this);
  90.     --(*this);
  91.     return temp;
  92. }
  94. Int24::operator int() const
  95. {
  96.     return value();
  97. }
  99. unsigned long Int24::value() const
  100. {
  101.     unsigned long retVal;
  103.     retVal = this->mBytes[2];
  104.     retVal <<= 8;
  105.     retVal |= this->mBytes[1];
  106.     retVal <<= 8;
  107.     retVal |= this->mBytes[0];
  109.     return retVal;
  110. }

你可以从my GitHub link下载Int24和Int48类，这里还有一个例子告诉你如何使用它。

展开查看全部
赞(0）分享  回复(0）举报  2022-11-19
我来回答

相关问题

    查看更多

    热门标签

    更多
    JavaquerypythonNode开发语言requestUtil数据库Table后端算法LoggerMessageElementParser

    最新问答

    更多
    • 蜀ICP备13028337号-1 大数据知识库 https://www.saoniuhuo.com © All rights reserved
    • 本站内容来源互联网,如果侵犯您的权益请联系我们删除, 联系方式：448109455@qq.com