Question

我有一个固定方法的班子,具有当地固定变量。我希望,一旦(我称之为这一功能的第1次)计算/评估变量以及随后的任何援引,再不评估。如何做到这一点? 在这里,我要说:

template<
    typename T1 = int, unsigned N1 = 1,
    typename T2 = int, unsigned N2 = 0,
    typename T3 = int, unsigned N3 = 0,
    typename T4 = int, unsigned N4 = 0,
    typename T5 = int, unsigned N5 = 0,
    typename T6 = int, unsigned N6 = 0,
    typename T7 = int, unsigned N7 = 0,
    typename T8 = int, unsigned N8 = 0,
    typename T9 = int, unsigned N9 = 0,
    typename T10 = int, unsigned N10 = 0,
    typename T11 = int, unsigned N11 = 0,
    typename T12 = int, unsigned N12 = 0,
    typename T13 = int, unsigned N13 = 0,
    typename T14 = int, unsigned N14 = 0,
    typename T15 = int, unsigned N15 = 0,
    typename T16 = int, unsigned N16 = 0>
struct GroupAlloc
{
    static const uint32_t sizeClass;
    static uint32_t getSize()
    {
        static uint32_t totalSize = 0;

        totalSize += sizeof(T1)*N1;
        totalSize += sizeof(T2)*N2;
        totalSize += sizeof(T3)*N3;
        totalSize += sizeof(T4)*N4;

        totalSize += sizeof(T5)*N5;
        totalSize += sizeof(T6)*N6;
        totalSize += sizeof(T7)*N7;
        totalSize += sizeof(T8)*N8;

        totalSize += sizeof(T9)*N9;
        totalSize += sizeof(T10)*N10;
        totalSize += sizeof(T11)*N11;
        totalSize += sizeof(T12)*N12;

        totalSize += sizeof(T13)*N13;
        totalSize += sizeof(T14)*N14;
        totalSize += sizeof(T15)*N15;
        totalSize += sizeof(T16)*N16;

        totalSize = 8*((totalSize + 7)/8);

        return totalSize;
    }
};

EDIT:

感谢大家的迅速帮助。页: 1 我选择了Tyler McHenry的回答,因为不需要任何比较,纯粹是静态的职能评价。我将需要这一分配者守则,这样就可以避免另一个“如果”更好。再次感谢!

EDIT:

gf 答案被证明是最佳的,因为它在汇编期间处理派任问题,并且使方案免于表面上的安全头痛和明确的初步化。然而,我尊重先前的最佳答案。我将在此提供信贷,而不是改变标准。感谢大家提供帮助!

Answer 1

发挥另一个固定功能,进行计算,并使用这一功能,使变数的初始化,例如,

static uint32_t computeSize() 
{
  uint32_t init_totalSize;

  // Lots of code

  return init_totalSize;
}

static uint32_t getSize()
{
  static uint32_t totalSize = computeSize();
  return totalSize;
}

法定变量得到保证,准确一度(首次使用包含这些变量的职能)。

<><>Edit>: 但notthread-safe. 该页非常详细地解释了为什么。

为使该编码便于操作,在关键部分对<代码> TotalSize的初始化(computeSize)进行总结是不够的,因为静态变量初始化是“复合魔法”,而且在使用之前,甚至在功能上第一次发言之前,随时可以进行初始化。你们需要做的是防止不止一个读物,甚至可以同时打上getSize,而这又可以达到另一个间接程度,例如:

static uint32_t computeSize() 
{
  uint32_t init_totalSize;

  // Lots of code

  return init_totalSize;
}

static uint32_t real_getSize()
{
  static uint32_t totalSize = computeSize();
  return totalSize;
}

static uint32_t getSize()
{
  uint32_t totalSize;
  /* --- Enter Critical Section (acquire lock) -- */
  totalSize = real_getSize();
  /* --- Exit Critical Section (release lock) -- */
  return totalSize;
}

这阻止两条线人甚至同时进入包含静态变量的职能,并确保该功能的初始化将在关键部分内进行。

Answer 2

将计算结果转化为辅助功能:

static uint32_t totalSize = calculateTotalSize();

只有在<条码>完全启动时才会援引助手的职能。

很晚,但你为什么在这里做(可能的话)时间计算? • 利用编辑时常数,你甚至永远不会有任何现成问题:

template<
  typename T1, unsigned N1,
  typename T2, unsigned N2,
  /* ... */
>
struct totalSize {
    static const uint32_t sum = 
        sizeof(T1)*N1
      + sizeof(T2)*N2
      /* ... */
      ;
    static const uint32_t value =
        8*((sum + 7)/8);
};

uint32_t GroupAlloc::getSize() {
    return totalSize<T1,N1,T2,N2,/*...*/>::value;
}

Answer 3

类似:

static uint32_t getSize()
{
    static uint32_t totalSize = 0;
    static bool computed = 0;
    if(computed)
      return totalSize;
    computed = 1;
    // ... go on with your computation

这样做是可能的。请注意,这是 t。

Answer 4

static uint32_t totalSize = 0;    // initialisation performed once only
if ( totalSize == 0 ) {
        totalSize += sizeof(T1)*N1;
        totalSize += sizeof(T2)*N2;
        totalSize += sizeof(T3)*N3;
        totalSize += sizeof(T4)*N4;
        // etc
}

EDIT:

EDIT:

友情链接