例如：
class caculate
{
public:
caculate();
virtual ~caculate();
private:
const int Relations[7][7];
};
这里的Rlations数组应该如何初始化？
26 个解决方案
#1
在构造函数中进行初始化
#2
在构造函数的初始化列表中
class A{
public:
const int i;
A():i(10){}
}
class A{
public:
const int i;
A():i(10){}
}
#3
楼上的不对
gz !gz !gz !gz !gz !gz !gz !gz !
gz !gz !gz !gz !gz !gz !gz !gz !
#4
我说的是一个数组，并不是单个变量啊，我试过了，vc6报了这样的错：
C:\COMPUTER-STUDY\c++\Calculator\caculate.cpp(14) : error C2536: 'caculate::Relations' : cannot specify explicit initializer for arrays
c:\computer-study\c++\calculator\caculate.h(18) : see declaration of 'Relations'
真不明白，那我应该怎么样初始化呢？
C:\COMPUTER-STUDY\c++\Calculator\caculate.cpp(14) : error C2536: 'caculate::Relations' : cannot specify explicit initializer for arrays
c:\computer-study\c++\calculator\caculate.h(18) : see declaration of 'Relations'
真不明白，那我应该怎么样初始化呢？
#5
在定义的时候初始化
class caculate
{
public:
caculate();
virtual ~caculate();
private:
const int Relations[7][7]={0，1，2、、、};
};
class caculate
{
public:
caculate();
virtual ~caculate();
private:
const int Relations[7][7]={0，1，2、、、};
};
#6
gz
#7
1.在构造函数中用for循环
2.使用memset
3.将int类型封装在一个类中以利用default constructor
2.使用memset
3.将int类型封装在一个类中以利用default constructor
#8
xi，你的第一种方法不行啊，编译通不过
第二种方法有点赖皮，第三种方法与主题相距甚远
我的看法：
首先，C++标准规定，只有static的const成员且必须是整数类型才能在申明的时候赋值，所以在申明的时候赋值已经是不可能的了
其次，在构造函数被执行时，其子对象已被构造，所以不能再对const成员赋值，这样，在构造函数中赋值也不可能了
最后，在初始化列表中由于不能对数组整体赋值，这也不可能了。
这样，我认为，不赖皮的话就么的办法
第二种方法有点赖皮，第三种方法与主题相距甚远
我的看法：
首先，C++标准规定，只有static的const成员且必须是整数类型才能在申明的时候赋值，所以在申明的时候赋值已经是不可能的了
其次，在构造函数被执行时，其子对象已被构造，所以不能再对const成员赋值，这样，在构造函数中赋值也不可能了
最后，在初始化列表中由于不能对数组整体赋值，这也不可能了。
这样，我认为，不赖皮的话就么的办法
#9
可有高手指正？
#10
呵呵，实在出乎我的意料之外，有这么多人关心这个问题呢^_^。请大家各抒己见，分不够的话我还可以再加！！
San_Daniel(丹少爷) :
为什么我这样写也不行呢？
static const int Relations[7]={1,1,0,0,0,1,1};
vc6报错：
c:\computer-study\c++\calculator\caculate.h(18) : error C2059: syntax error : '{'
c:\computer-study\c++\calculator\caculate.h(18) : error C2334: unexpected token(s) preceding '{'; skipping apparent function body
San_Daniel(丹少爷) :
为什么我这样写也不行呢？
static const int Relations[7]={1,1,0,0,0,1,1};
vc6报错：
c:\computer-study\c++\calculator\caculate.h(18) : error C2059: syntax error : '{'
c:\computer-study\c++\calculator\caculate.h(18) : error C2334: unexpected token(s) preceding '{'; skipping apparent function body
#11
用枚举吧
#12
static const 是不能在类内定义的
#13
在构造函数中初始化
#14
我觉得xi的第三个方法不错:)
#15
LANDFISH,你可能没看清我的话吧，只有static的const成员且必须是整数类型才能在申明的时候赋值，int[] 不是整型耶
还有，VC在这一点上没遵循标准，什么类型申明时都休想初始化，真毒
还有，VC在这一点上没遵循标准，什么类型申明时都休想初始化，真毒
#16
看C++ Standard 9.2
#17
这样：
class name
{
static const int Relations[7];
//code others
};
const int name::Relations[7]={1,1,0,0,0,1,1};
class name
{
static const int Relations[7];
//code others
};
const int name::Relations[7]={1,1,0,0,0,1,1};
#18
shima
#19
magicblue，你的是定义时(definition)初始化，不是申明(declaration)时初始化。定义部分应该在实现文件(.CPP)中.不应该在申明文件(.H)中
#20
const int Relations[7][7];
为什么要声明它呢？
为什么不把它作为枚举或静态或全局的书组呢？
浪费空间
为什么要声明它呢？
为什么不把它作为枚举或静态或全局的书组呢？
浪费空间
#21
TO cgaga(红枫剪影):
是这样的，Relations是一个对照表，每一个该类的实例对象都要用到它，而且是不能修改的，所以我想将它作为一个类的常成员。另一方面，我也很想知道，如果在一个类中有一个常量数组应该如何对它进行初始化。
to xi:
我查了一下msdn,memset好象是针对字符串的阿，int型的数组也可以用吗？还有，你的第三种方法我不大明白，能否详细说明之？
是这样的，Relations是一个对照表，每一个该类的实例对象都要用到它，而且是不能修改的，所以我想将它作为一个类的常成员。另一方面，我也很想知道，如果在一个类中有一个常量数组应该如何对它进行初始化。
to xi:
我查了一下msdn,memset好象是针对字符串的阿，int型的数组也可以用吗？还有，你的第三种方法我不大明白，能否详细说明之？
#22
好象没什么人回贴了，“推”一把^_^
#23
不好意思，对问题没有仔细考虑。前述1)2)方法确实行不通。
新的方法是：
1)将Relations在类中声明为static const int Relations[7][7];
在*.cpp中这样初始化：
const int caculate::Relations[][7]=
{
{1, 2, 3}, //没有显式赋值的自动被赋为0
{4, 5, 6}
};
2)将int类型封装在一个类中以利用default constructor，一个样例，可以根据实际情况以最少的接口满足需要：
class Integer
{
int m_i;
public:
Integer(const int i=0): m_i(i) {}
Integer(const Integer& x): m_i(x.m_i) {}
operator int() { return m_i; }
Integer& operator=(const Integer& x)
{
if (this == &x)
return *this;
m_i=x.m_i;
}
Integer& operator+=(const Integer& x)
{
m_i += x.m_i;
return *this;
}
Integer& operator-=(const Integer& x)
{
m_i -= x.m_i;
return *this;
}
friend ostream& operator<<(ostream& out, const Integer& x)
{ return out << x.m_i; }
//...
};
新的方法是：
1)将Relations在类中声明为static const int Relations[7][7];
在*.cpp中这样初始化：
const int caculate::Relations[][7]=
{
{1, 2, 3}, //没有显式赋值的自动被赋为0
{4, 5, 6}
};
2)将int类型封装在一个类中以利用default constructor，一个样例，可以根据实际情况以最少的接口满足需要：
class Integer
{
int m_i;
public:
Integer(const int i=0): m_i(i) {}
Integer(const Integer& x): m_i(x.m_i) {}
operator int() { return m_i; }
Integer& operator=(const Integer& x)
{
if (this == &x)
return *this;
m_i=x.m_i;
}
Integer& operator+=(const Integer& x)
{
m_i += x.m_i;
return *this;
}
Integer& operator-=(const Integer& x)
{
m_i -= x.m_i;
return *this;
}
friend ostream& operator<<(ostream& out, const Integer& x)
{ return out << x.m_i; }
//...
};
#24
哦，解决了，谢谢各位，特别是xiterator，San_Daniel(丹少爷)，magicblue(小飞侠)的帮助。给分啦！
#25
呀，给错分啦！magicblue(小飞侠)，对不起啊，你的分好像给了下面的人，是在抱歉！！
#26
http://www.csdn.net/expert/TopicView.asp?id=199746
magicblue(小飞侠)请到这里拿分，是在不好意思。
magicblue(小飞侠)请到这里拿分，是在不好意思。
#1
在构造函数中进行初始化
#2
在构造函数的初始化列表中
class A{
public:
const int i;
A():i(10){}
}
class A{
public:
const int i;
A():i(10){}
}
#3
楼上的不对
gz !gz !gz !gz !gz !gz !gz !gz !
gz !gz !gz !gz !gz !gz !gz !gz !
#4
我说的是一个数组，并不是单个变量啊，我试过了，vc6报了这样的错：
C:\COMPUTER-STUDY\c++\Calculator\caculate.cpp(14) : error C2536: 'caculate::Relations' : cannot specify explicit initializer for arrays
c:\computer-study\c++\calculator\caculate.h(18) : see declaration of 'Relations'
真不明白，那我应该怎么样初始化呢？
C:\COMPUTER-STUDY\c++\Calculator\caculate.cpp(14) : error C2536: 'caculate::Relations' : cannot specify explicit initializer for arrays
c:\computer-study\c++\calculator\caculate.h(18) : see declaration of 'Relations'
真不明白，那我应该怎么样初始化呢？
#5
在定义的时候初始化
class caculate
{
public:
caculate();
virtual ~caculate();
private:
const int Relations[7][7]={0，1，2、、、};
};
class caculate
{
public:
caculate();
virtual ~caculate();
private:
const int Relations[7][7]={0，1，2、、、};
};
#6
gz
#7
1.在构造函数中用for循环
2.使用memset
3.将int类型封装在一个类中以利用default constructor
2.使用memset
3.将int类型封装在一个类中以利用default constructor
#8
xi，你的第一种方法不行啊，编译通不过
第二种方法有点赖皮，第三种方法与主题相距甚远
我的看法：
首先，C++标准规定，只有static的const成员且必须是整数类型才能在申明的时候赋值，所以在申明的时候赋值已经是不可能的了
其次，在构造函数被执行时，其子对象已被构造，所以不能再对const成员赋值，这样，在构造函数中赋值也不可能了
最后，在初始化列表中由于不能对数组整体赋值，这也不可能了。
这样，我认为，不赖皮的话就么的办法
第二种方法有点赖皮，第三种方法与主题相距甚远
我的看法：
首先，C++标准规定，只有static的const成员且必须是整数类型才能在申明的时候赋值，所以在申明的时候赋值已经是不可能的了
其次，在构造函数被执行时，其子对象已被构造，所以不能再对const成员赋值，这样，在构造函数中赋值也不可能了
最后，在初始化列表中由于不能对数组整体赋值，这也不可能了。
这样，我认为，不赖皮的话就么的办法
#9
可有高手指正？
#10
呵呵，实在出乎我的意料之外，有这么多人关心这个问题呢^_^。请大家各抒己见，分不够的话我还可以再加！！
San_Daniel(丹少爷) :
为什么我这样写也不行呢？
static const int Relations[7]={1,1,0,0,0,1,1};
vc6报错：
c:\computer-study\c++\calculator\caculate.h(18) : error C2059: syntax error : '{'
c:\computer-study\c++\calculator\caculate.h(18) : error C2334: unexpected token(s) preceding '{'; skipping apparent function body
San_Daniel(丹少爷) :
为什么我这样写也不行呢？
static const int Relations[7]={1,1,0,0,0,1,1};
vc6报错：
c:\computer-study\c++\calculator\caculate.h(18) : error C2059: syntax error : '{'
c:\computer-study\c++\calculator\caculate.h(18) : error C2334: unexpected token(s) preceding '{'; skipping apparent function body
#11
用枚举吧
#12
static const 是不能在类内定义的
#13
在构造函数中初始化
#14
我觉得xi的第三个方法不错:)
#15
LANDFISH,你可能没看清我的话吧，只有static的const成员且必须是整数类型才能在申明的时候赋值，int[] 不是整型耶
还有，VC在这一点上没遵循标准，什么类型申明时都休想初始化，真毒
还有，VC在这一点上没遵循标准，什么类型申明时都休想初始化，真毒
#16
看C++ Standard 9.2
#17
这样：
class name
{
static const int Relations[7];
//code others
};
const int name::Relations[7]={1,1,0,0,0,1,1};
class name
{
static const int Relations[7];
//code others
};
const int name::Relations[7]={1,1,0,0,0,1,1};
#18
shima
#19
magicblue，你的是定义时(definition)初始化，不是申明(declaration)时初始化。定义部分应该在实现文件(.CPP)中.不应该在申明文件(.H)中
#20
const int Relations[7][7];
为什么要声明它呢？
为什么不把它作为枚举或静态或全局的书组呢？
浪费空间
为什么要声明它呢？
为什么不把它作为枚举或静态或全局的书组呢？
浪费空间
#21
TO cgaga(红枫剪影):
是这样的，Relations是一个对照表，每一个该类的实例对象都要用到它，而且是不能修改的，所以我想将它作为一个类的常成员。另一方面，我也很想知道，如果在一个类中有一个常量数组应该如何对它进行初始化。
to xi:
我查了一下msdn,memset好象是针对字符串的阿，int型的数组也可以用吗？还有，你的第三种方法我不大明白，能否详细说明之？
是这样的，Relations是一个对照表，每一个该类的实例对象都要用到它，而且是不能修改的，所以我想将它作为一个类的常成员。另一方面，我也很想知道，如果在一个类中有一个常量数组应该如何对它进行初始化。
to xi:
我查了一下msdn,memset好象是针对字符串的阿，int型的数组也可以用吗？还有，你的第三种方法我不大明白，能否详细说明之？
#22
好象没什么人回贴了，“推”一把^_^
#23
不好意思，对问题没有仔细考虑。前述1)2)方法确实行不通。
新的方法是：
1)将Relations在类中声明为static const int Relations[7][7];
在*.cpp中这样初始化：
const int caculate::Relations[][7]=
{
{1, 2, 3}, //没有显式赋值的自动被赋为0
{4, 5, 6}
};
2)将int类型封装在一个类中以利用default constructor，一个样例，可以根据实际情况以最少的接口满足需要：
class Integer
{
int m_i;
public:
Integer(const int i=0): m_i(i) {}
Integer(const Integer& x): m_i(x.m_i) {}
operator int() { return m_i; }
Integer& operator=(const Integer& x)
{
if (this == &x)
return *this;
m_i=x.m_i;
}
Integer& operator+=(const Integer& x)
{
m_i += x.m_i;
return *this;
}
Integer& operator-=(const Integer& x)
{
m_i -= x.m_i;
return *this;
}
friend ostream& operator<<(ostream& out, const Integer& x)
{ return out << x.m_i; }
//...
};
新的方法是：
1)将Relations在类中声明为static const int Relations[7][7];
在*.cpp中这样初始化：
const int caculate::Relations[][7]=
{
{1, 2, 3}, //没有显式赋值的自动被赋为0
{4, 5, 6}
};
2)将int类型封装在一个类中以利用default constructor，一个样例，可以根据实际情况以最少的接口满足需要：
class Integer
{
int m_i;
public:
Integer(const int i=0): m_i(i) {}
Integer(const Integer& x): m_i(x.m_i) {}
operator int() { return m_i; }
Integer& operator=(const Integer& x)
{
if (this == &x)
return *this;
m_i=x.m_i;
}
Integer& operator+=(const Integer& x)
{
m_i += x.m_i;
return *this;
}
Integer& operator-=(const Integer& x)
{
m_i -= x.m_i;
return *this;
}
friend ostream& operator<<(ostream& out, const Integer& x)
{ return out << x.m_i; }
//...
};
#24
哦，解决了，谢谢各位，特别是xiterator，San_Daniel(丹少爷)，magicblue(小飞侠)的帮助。给分啦！
#25
呀，给错分啦！magicblue(小飞侠)，对不起啊，你的分好像给了下面的人，是在抱歉！！
#26
http://www.csdn.net/expert/TopicView.asp?id=199746
magicblue(小飞侠)请到这里拿分，是在不好意思。
magicblue(小飞侠)请到这里拿分，是在不好意思。