在以下代码中
class someClassB;
class someClassA
{
public:
someClassA(int x, int y);
private:
someClassB* B;
};
class someClassB
{
public:
someClassB(int x, int y);
private:
int x;
int y;
someClassA A;
};
someClassA::someClassA(int i, int j)
{
B->x = i;
B->y = j;
}
someClassB::someClassB(int i, int j)
{
x = i;
y = j;
A = new someClassA(i, j);
}
为什么我得到一个错误,''someClassB'的构造函数必须显式初始化没有默认构造函数的成员'A'？我是不是在someClassB的构造函数中初始化'A'？
有人可以向我解释为什么这个代码打印出"abeb"而不是abcb？我理解这是因为你从list1引用list2所以改变list2也改变了list1但是我并不完全理解它.
char [] list1 = {'a','b','c','d'};
char [] list2 = list1;
list2[2] = 'e';
list1[3] = list2[1]
for (char a: list1)
out.print(a)`
为什么在此代码中没有应用相同的逻辑(我理解的逻辑)？它打印出x作为"5"是从我从上面的代码中理解它应该是7？
int x = 5;
int y = x;
y += 2;
out.print(x);
我将发布我的代码然后解释我的查询:
typedef std::shared_ptr<SEntity> Entity;
//Scene_Ids is an enum
static std::map<Scene_Ids, std::vector<Entity> > m_scene_entities;
std::shared_ptr<SEntity>& SEntityManager::getEntity(const std::string& entity_name)
{
int counter = 0;
for (auto iter = m_scene_entities.begin(); iter != m_scene_entities.end(); ++iter)
{
if (iter->second[counter]->getId() == entity_name)
return iter->second[counter];
counter++;
}
//What would I return if the entity couldn't be found?
}
代码基本上解释了这一切.我有一个方法,如果在地图内的std :: vector中找到"实体",它将返回对它的std :: shared_ptr类型的引用.但是,由于我没有返回指针,我无法返回nullptr.在失败的情况下我能回报什么？
另外,我知道std :: shared_ptr意味着在几个不同的地方有副本.为此,我真的需要返回一个引用,还是可以按值返回它？
谢谢!
可以理解,编译器将不允许以下内容:
const int ci = 1000;
int &r = ci;
因为这意味着我可以尝试通过r来改变ci的值,但ci是const.
为什么然后允许以下内容,除了首先为r分配非const int之外,它与上面相同？
int i;
const int ci = 1000;
int &r = i;
r = ci;
如果您尝试通过r更改ci,则ci将保持相同的值.然而,与第一个示例不同,它不会被编译器捕获.对此有解释吗？
我想知道如何在UML图中在类中包含对自身的引用列表.
例如:模型由许多组件组成.组件可以包含对其子组件的引用列表.
我如何在UML图中说明这一点？
我想声明一个类的一些属性.我正在考虑为类中我想要的属性创建私有变量.
然后通过引用公开私有变量.但是我通过指针也可以传递私有变量的地址.因此,类的用户可以修改变量.
那么哪种方式通过引用或指针会更好,如下例所示？
class ExampleClass
{
private:
int age;
public:
//This function allows access via reference
int& GetAgeByReference()
{
int& refAge= age;
return refAge;
}
//This function allows access via pointer
int* GetAgeByPointer()
{
int* pointAge= &age;
return pointAge;
}
}
据我所知,this是一个指针,*this是一个参考.所以,如果我有一个类Sample和一个方法,如:
Sample operator++(){
int i;
for(i=0;i<this->length;i++){
this->array[i]+=1;
}
return *this;
}
或者另一种方法.
Sample &operator++(){
int i;
for(i=0;i<this->length;i++){
this->array[i]+=1;
}
return *this;
}
在这两者之间,这将是正确的方法吗？
参考这个,如果我有std::map<double, Object> my_map,是以下等价物？
Object& obj = my_map[1];
Object obj = my_map[1];
我知道operator[]通过引用返回,第一种方式,正确的方法,而不是创建副本,或者它们是相同的.如果它们是相同的,我不确定它们为什么会这样.
同样,如果我也有......
std::map<double, Object>::iterator it;
以下是类似的吗？
Object& obj = it->second;
Object obj = it->second;
我制作了这个c ++代码:
std::string const & Operand::toString() const
{
std::ostringstream convert;
convert << this->value;
return convert.str();
}
编译器告诉我: returning reference to temporary
难道我被迫把convert.str()我的Operand班？
编辑:这是一个学校运动,我不能改变原型
void RemoveGreenEffect::processImage(vector<Point>& points)
{
for (int i = 0; i < points.size(); ++i)
{
points[i].setGreen(0);
}
}
此函数正确引入向量并在本地进行更改.但是,当程序返回main时,它不会保留更改.有人可以解释我做错了吗？如果有帮助,这里是main的调用函数.
for (int i = 0; i < ppm.getRows(); ++i)
{
my_effect->processImage(picture.getPicture()[i]);
}
my_effect是一个基类指针,指向派生对象RemoveGreenEffect.getPicture()是Point对象向量的向量,因此getPicture()[i]是Point类的向量.目标是一次一行地删除图片中的所有绿色值像素,但同样,更改仅在本地工作.
编辑,这是getPicture()
vector<vector<Point>> PointFormatPicture::getPicture()
{
return _picture;
}
这是_picture是什么
vector<vector<Point>> _picture;