class meun
{
public:
static int i;
static int j;
static int k;
static int l;
double price[4]={4,5,7,6 };
string food1=”xxx“;
string food2="xxx";
string food3="xxx";
string food4="xxx";
看你的描述，这应该是一个类的定义，类是一个蓝图，一般是需要实例化才可以给数据成员赋值，如果需要在定义期间设初始值的话，就设为静态成员，并且在类外（cpp文件）进行赋值
定义一个重载构造函数，
public: meun(int i,int j, int k, int l)
{
this->i=i;
this->j=j;
this->k=k;
this->l=l;.
}
在对应的cpp文件中初始化，如：int meun::i = 1;
typedef struct {
float32 Valpha; // alfa voltage
float32 Ealpha; // alfa-axis back EMF
float32 Zalpha; // alfa sliding control
float32 Gsmopos; // Motor dependent control gain
float32 EstIalpha; // Est alfa current
float32 Fsmopos; // Motor Parameter
float32 Vbeta; // beta voltage
float32 Ebeta; // beta back EMF
float32 Zbeta; // beta sliding control
float32 EstIbeta; // Est beta current
float32 Ialpha; // alfa current
float32 IalphaError; // alfa current error
float32 Kslide; // Sliding control gain
float32 Ibeta; // Input: beta stator current
float32 IbetaError; // beta current error
float32 Kslf; // Sliding control filter gain
int16 IQAngle;
float32 E0; // 0.5
} Angle_SMO, *p_Angle_SMO;
#define Angle_SMO_DEFAULTS {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0}
Angle_SMO Angle_SMOPare=Angle_SMO_DEFAULTS ;
在构建对象的时候会调用构造函数，你可以自己写个构造函数进行赋初值
一般进行成员变量初始化用两种方法
第一种是通过在构造函数内赋值
class Point
{
public:
Point(){ _x = 0; _y = 0;};
Point( int x, int y ){ _x = 0; _y = 0; }
private:
int _x, _y;
};
第二种是使用初始化列表
class Point
{
public:
Point():_x(0),_y(0){};
Point( int x, int y ):_x(x),_y(y){}
private:
int _x, _y;
};
这两种用法是有区别的
一、在有些情况下，必须使用初始化列表。特别是const和引用数据成员被初始化时。
class Point
{
// 这个类的定义就要求使用初始化成员列表，因为const成员只能被初始化，不能被赋值
public:
Point():_x(0),_y(0){};
Point( int x, int y ):_x(x),_y(y){}
//Point(){ _x = 0; _y = 0;}
//Point( int x, int y ){ _x = 0; _y = 0; }
private:
const int _x, _y;
};
二、是从效率方面来说的，对于内置类型或复合类型，差异不会太大，但对于非内置数据类型，差异还是很明显的
如再给Point类添加一个新的string类型的成员变量
class Point
{
const int _x, _y;
string _name;
};
构造函数内赋值进行初始化
Point( int x, int y, string name ){ _x = 0; _y = 0; _name = name; }
_name = name 这个表达式会调用string类的缺省构造函数一次，再调用Operator=函数进行赋值一次。所以需调用两次函数：一次构造，一次赋值
用初始化列表进行初始化
Point( int x, int y, string name ):_x(x),_y(y), _name(name){}
_name会通过拷贝构造函数仅以一个函数调用的代码完成初始化
即使是一个很简单的string类型，不必要的函数调用也会造成很高的代价。随着类越来越大，越来越复杂，它们的构造函数也越来越大而复杂，那么对象创建的代价也越来越高，所以一般情况下使用初始化列表进行初始化，不但可以满足const和引用成员的初始化要求，还可以避免低效的初始化数据成员。
楼主的问题，我理解你的意思就是如何在创建类对象时就对这些类中变量赋值的问题：分几种情况：1.如果类中的变量是static类型的，
这个是必须在类外定义，不然不能使用的，就像楼主代码中的i,j,k,l变量。可以在类外这样定义：int meun:i=0;这样；2.const类型的变量，这种变量只能
在类初始化列表中进行，因为const是只读类型，必须在类初始化列表中初始化，不然就没有机会了。类中的初始化序列也可以定义其他的变量，比如拿楼主的类：
meun(string a):food1(a){};3.就是类中成员变量是const static 时，这时只能是在声明时就初始化，比如在类meun中有一个成员变量：static const int a=10;
当然还可以定义一个默认的构造函数或者满足要求的构造函数来进行初始化。希望能帮助到楼主！
代码：
class meun
{
private:
const int j;
string food1;
static int i;
static const int k=9;
//初始化列表
public:
meun(int jj=9,string f="XXX"):j(jj),food1(f){};
};
int meun:i=0;
希望可以帮助到你！
//abc.h，abc类的头文件
class abc
{
public:
abc();
int a;
static int b;
};
//abc.cpp，abc类的源文件
abc::abc()
{
a = 123;//方式一，构造函数给类成员初始化
}
static int abc::b = 321;//方式二，静态成员初始化
//main.cpp
abc a1;//方式一前提需要进行类的实例化
//上面是两种给数据成员初始化的方式，构造函数可以换成自定义函数的方式。
你用的类，若没有写构造函数，创建对象系统会自动调用缺省构造函数，里面的值自动初始化为对应类型的0
class meun
{
public:
static int i;
static int j;
static int k;
static int l;
double price[4];
string food1;
string food2;
string food3;
string food4;
meun()
: price{0.0,0.0,0.0,0.0}
, food1()
, food2()
, food3()
, food4()
{
}
meun(double inPrice[4], string inFood1, string inFood2, string inFood3, string inFood4)
: price{ inPrice[0],inPrice[1],inPrice[2],inPrice[3] }
, food1(inFood1)
, food2(inFood2)
, food3(inFood3)
, food4(inFood4)
{
}
};
int meun::i = 0;
int meun::j = 0;
int meun::k = 0;
int meun::l = 0;
class meun
{
public:
static int i;
static int j;
static int k;
static int l;
double price[4];
string food1;
string food2;
string food3;
string food4;
meun()
: price{0.0,0.0,0.0,0.0}
, food1()
, food2()
, food3()
, food4()
{
}
meun(double inPrice[4], string inFood1, string inFood2, string inFood3, string inFood4)
: price{ inPrice[0],inPrice[1],inPrice[2],inPrice[3] }
, food1(inFood1)
, food2(inFood2)
, food3(inFood3)
, food4(inFood4)
{
}
};
int meun::i = 0;
int meun::j = 0;
int meun::k = 0;
int meun::l = 0;
静态数据成员在cpp中使用 CLASSNAME：：static-mem = value；的方式进行初始化，因为静态数据成员是该类公有，不属于某个对象；
普通的数据成员在构造函数中进行初始化。
两种： 初始化列表
重载构造函数
定义一个构造函数
public: meun()
{
i = xxx;
j = xxx;
...
}
楼主之前问了很多问题，我都作了回答，但是一直没有采纳，如果有不明白请追问，如果问题解决，请及时采纳，谢谢