Question

下面的代码是一个未完成的代码，因为我还不完全熟悉如何在C ++中使用类，我需要一些指导如何在类定义的int开头初始化这么大的整数，很多人stackoverflow建议我不要对所有这些变量使用构造函数。我可以使用什么以及如何使用？为什么我不应该用构造函数初始化许多变量？

我最终想要实现的是计算RSA算法中的c的整数，并且我想为三个用户执行此操作。这样程序就会为每个程序生成2个密钥。

#include <iostream>
#include <vector>
#include <math.h>
#include <algorithm>
#include <boost/dynamic_bitset.hpp>

using namespace std;

class LFSR:
{
   int y = 0;
   int turnCount = 0;
   int count1 = 0, count0 = 0;
   int xx = 0;
   int polyLoc;
   int p = 0;
   int q = 0;
   int d = 0;
   int n = 0;
   int end = 0;
   int f = 0;
   int e = 0;
   int m = 0;
   int c = 0;
   int l = 0, g = 0;
   boost::dynamic_bitset<> inpSeq(5);
   boost::dynamic_bitset<> operSeq(5);
   boost::dynamic_bitset<> bit(5);
   vector <int> xorArray;
   vector <int> keyReg;

  public:
    LFSR ();
   int key ()
   {
    while(polyLoc>0)
    {
      xorArray.push_back(polyLoc%10);
      polyLoc/=10;
    }
    sort(xorArray.rbegin(), xorArray.rend());
    operSeq = inpSeq;
    keyReg.push_back(inpSeq[0]);
    int x = xorArray[0];
    do {
     for (unsigned int r = 1; r < xorArray.size(); r++)
     {
       bit[seq_end] = operSeq[x];
       y = xorArray[r];
       bit[seq_end] = bit[seq_end] ^ operSeq[y];
     }
     operSeq >>= 1;
     operSeq[seq_end]  = bit[seq_end];
     keyReg.push_back(operSeq[0]);
     turnCount ++;
   }
   while ((operSeq != inpSeq) && (turnCount < 1024));
   for ( unsigned int i = 0; i < keyReg.size(); i++)
   {
    if (keyReg[i]==1)
    {
     m = m + int(pow(2,i));
    }
  }
  n = p*q;
  f = (p-1)*(q-1);
  for (int k = 0; end < 1; k++)
  {
   if ( (1+k*f)%d == 0)
   {
    end = 2;
    e = (1+(k*f))/d;
   }
  }
  g = int(pow(m,e));
  c = g%n;
  return c;
 }
};

LFSR::LFRS()
{

}

int main ()
{
}

Answer 1

与 @AbhiP 一样，使用initializer lists。

class Baz
{
    public:
            Baz( std::string foo ) : foo( foo ) { }
    private:
        std::string foo;
};

如果您使用的是兼容c ++ 11的编译器，则可以使用In-class member initializers。

class A 
{
public:
    int a = 7;
};

Answer 2

由于p，q和d是变体，而所有其他都是不变量（至少在构造期间），您希望为用户提供在构造函数中设置变体的机会。

类似的东西：

LFSR::LFSR(int p_, int q_, int _d)
: p(p_)
, q(q_)
, d(d_)
{
}

如上所述在类定义中设置不变量将适用于c ++ 11，而不适用于c ++ 98。

如果你有一个较旧的编译器，你需要这样做：

LFSR::LFSR(int p_, int q_, int d_)
: y(0)
, turnCount(0)
// ... all other member variables in order of definition ...
, p(p_)
, q(q_)
, d(d_)
, n(0)
// ... all the rest here ...
{
}

在C ++类中初始化大量变量

2 个答案: