在下面的C++程序中,从函数修改静态数据成员const可以正常工作:
class A
{
public:
static int a; // static data member
void set() const
{
a = 10;
}
};
但是,从const函数修改非静态数据成员不起作用:
class A
{
public:
int a; // non-static data member
void set() const
{
a = 10;
}
};
为什么const
我无法理解不允许非成员函数使用修饰符(如const或volatile )的原因。
下面是我很累的示例代码
class A
{
private:
int var;
public:
int func();
};
int A::func()
{
// Some calculation on using var
int temp = var + 10;
return temp;
}
void func2( const A& tempObj ) const;
void func2( const A& tempObj )
{
std:
考虑以下三个程序:
// program 1
#include<new>
struct A {
const int a = 0;
int b = 0;
};
int main() {
auto a = new A[2];
new(a+1) A;
a[1].b = 1;
}
// program 2
#include<new>
struct A {
const int a = 0;
int b = 0;
};
int main() {
auto a = new A[2];
new(a) A
您好,我收到错误C2088:'+=':非法的联合错误在visual studio上...同样的代码在gcc上也能正常工作。你能告诉我在c++中用visual studio解决这个问题的解决方案吗?
typedef union {
float sm[8];
} Su;
typedef union {
Su v;
float bm[8];
} Bu;
int main() {
Bu A1, A2;
A2.v.sm[0] = 12.5;
// .... some assignments here
A1.v += A
当自由算子函数和成员算子函数都被定义时,哪一个被用来比较?
#include <iostream>
class A;
class B;
bool operator==(const A &a, const B &b){ return true; };
class A
{
public:
bool operator==( const B &rhs ){ return false; };
};
class B
{
};
int main( int argc, char **argv )
{
A a;
B b;
if( a ==
我创建了一个指向动态分配的对象实例的const指针,我无法理解对象本身是否是const。
首先,我试图使用指针调用一个非const成员函数,正如所预期的那样,它会导致编译错误,因为(这是我的解释,不知道它是否为真)由成员函数创建的指针被分配给该const指针。它没有产生任何结果。
其次,我试图取消对指针的引用,并调用该非const成员函数。我认为现在成员函数创建的这个指针不会是const指针,因为编译不能知道p返回的对象(即*p)是否由const指针返回。原来是我弄错了。
成员函数如何理解这一点?
#include<iostream>
class A
{
int a=4;
请考虑以下示例:
#include <new>
struct FunctionObject
{
int operator()() // non-const, modifies the state of this object
{
i += 1;
j += 2;
return i + j;
}
int i = 0;
int j = 0;
};
struct Wrapper
{
explicit Wrapper(const FunctionObject& input_objec
考虑以下代码:
struct X
{
int x;
};
X xInstance;
class A
{
public:
operator X*()
{
return &xInstance;
}
};
int main()
{
A a;
*a = X(); // ok
a[0] = X(); // ok
// a->x = 0; // error
}
A将隐式转换为指针类型。我试图在需要指针的三种上下文中使用它;前两行很好,但是试图通过operator->引用operator->字段
C++自动将bool值设置为true或false,即使类型实际持有1字节值。
所以bool(123) == true是真的
int i = 123;
bool b = i;
int j = b;
j取值1。
但是,当reinterpret_cast与bool*指针一起使用时,情况是否仍然如此?例如。
static_assert(sizeof(bool) == 1, "assuming sizeof(bool) is one in this example...");
std::uint8_t i = 123;
bool* b = reinterpret_cast<boo
我在这里看到了关于const成员函数允许修改静态成员的多个问题。但不确定我的问题是否属于同一类别。在我的示例中,静态成员函数修改类的静态对象,而不是类的静态成员。为什么我的例子有效?
class Base
{
public:
virtual const Base& fun (const Base& n) const = 0;
};
class Child : public Base
{
int content;
public:
Child(int i = 0) : content(i) {}
const Base& fun (const
关于名称空间限定的问题:为什么下面没有推断函数的名称空间?
namespace X {
void func(int) {}
struct Z{
void func(){
//func(int{}); does not compile
X::func(int{}); // this works
}
};
}
int main() {
X::Z z;
z.func();
}
下面的代码正在抛出一条错误消息,我不知道问题是什么--是单词static,还是const?我做错了什么?
#include <iostream>
using namespace std;
class SampleClass
{
private:
int value;
static int counter;
public:
SampleClass(int i)
{
value = i;
counter++;
}
static int countSomeClass() const
{
编译Objective-C++时,我得到以下诊断结果:
'MyClass' cannot be shared between ARC and non-ARC code; add a non-trivial copy assignment operator to make it ABI-compatible
缺少复制构造函数和析构函数也会出现类似的错误。添加必要的方法很容易,但它们通常没有意义,特别是对于我想使其不可复制的类,而且我不会混淆ARC和非ARC代码(至少不是故意的)。
为什么我会收到这样的消息,我可以在不为所有C++类编写无意义的成员函数的情况下摆脱它吗?