请考虑以下代码:
struct AA
{
int& rr;
};
是否有一种方法可以获得指向AA::rr的指针(或者引用)?
AA* aa;
auto mm = &AA::rr; // error: cannot create pointer to reference member ‘AA::rr’
aa ->* mm;
同样在gcc-7.0.1,decltype(AA::mm)就是int&。这是按照标准吗?这有意义吗?
编辑
对不起,伙计们,我把问题表述得不太好。没有抱怨引用不是对象或者没有指向引用的指针的事实。目标是很自私的。考虑到struct AA
最近,我在我的代码库中看到了下面的代码(下面给出的简化版本),并对此产生了怀疑:
class B;
class A
{
public:
A():m_A("testA"){}
B& getB()
{
return m_B;
}
B* getBPtr() //== > written to explain the problem clearly
{
return &m_B;
}
private:
B m_B;
};
class B
{
publi
我遇到了奇怪的行为,不知道原因。我有两个项目A和B。A引用System.Web程序集和B引用A。我将使用语句添加到项目B类using A中。它可以正常工作,直到我开始使用linq语句。我得到编译错误
The type 'System.Web.UI.Control' is defined in an assembly that is not referenced. You must add a reference to assembly 'System.Web, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f
如果这是个愚蠢的问题,很抱歉。我刚开始学斯威夫特。我的日常工作主要使用php。Apple Store的Swift教科书使用了以下示例(我将其修改为较短的版本),以演示弱引用的用法:
class Person {
var apartment: Apartment?;
}
class Apartment {
weak var tenant: Person?;
}
var john: Person?; john = Person();
var number73: Apartment?; number73 = Apartment();
john!.apar
我试图查看弱引用何时通过null返回get()
String string = new String("abc");
WeakReference<String> wi = new WeakReference<>(string);
WeakReference<String> sr = new WeakReference<>(new String("another"));
System.out.println(wi.get());
System.out.println(sr.get());
System.gc();
S
-、-和的文档都包括如下内容的一行(摘自PhantomReference):
届时,它将原子地清除对该对象的所有幻影引用,以及对任何其他可从该对象访问的幻影可达对象的所有幻影引用。
让我困惑的是关于另一个幻影可达对象的部分。
如果我理解正确的话,这就描述了这种情况:
物体:
一个
B
参考文献:
->:强引用
-P->:幻影参考
-> A
-P-> B -> A
因此,由于某种原因,垃圾收集器还没有确定B仅仅是幻影可达的。现在,如果A变成了幻影,并且垃圾收集器检测到了这一点,那么就需要(根据上面引用的文档)清除对B的引用。
正如所解释的那样,不同类别的值根据以下优先顺序绑定到不同种类的引用:
struct s {};
void f ( s&); // #1
void f (const s&); // #2
void f ( s&&); // #3
void f (const s&&); // #4
const s g ();
s x;
const s cx;
f (s ()); // rvalue #3, #4, #2
f (g ()); // const rvalue #4, #2
f (x); // lvalu
书中说:因为引用不是对象,所以我们可能不会定义引用。
int ival = 1024;
int &refVal = ival;
refVal = 2;
int ii = refVal;
int &refVal3 = refVal; // isn't this a definition of ref to ref?
int i = refVal;
int &refVal4 = 10;
double dval = 3.14;
int &refVal5 = dval;
但是,这一行并不是错误的,因为refVal3说它只是refVal的另一个别名,而refVal
我的问题是在Java中引用是如何工作的。据我所理解,阅读引用是一个正式的名称,允许使用引用指向的对象。考虑以下代码:
public class A{
private int a = 0;
void mutate(){
a++;
}
}
public void foo (A a){
a.mutate();
}
public static void main(String[] args){
A a = new A(); //a is a reference to the object of type A
foo(a);
}
a函
class DoublyLLNode<T>{
var value<T>?
weak var prev: DoublyLLNode? = nil
var next: DoublyLLNode? = nil
}
为什么前一个或下一个值被标记为weak?我们不能让两者都变弱吗?若有,原因为何?如果没有解释的话。
class A {
var b: B
init(b: B) {
self.b = b
}
deinit {
print(" Destroying A")
}
}
class B {
weak var a: A?
deinit {
print(" Destroying B")
}
}
func setup(_ a: inout A?, _ b: inout B?) {
b = B()
a = A(b:
为了保存对对象的引用,使用带&和非的std::shared_ptr有什么区别?
class A{};
class B
{
private:
std::shared_ptr<A>&obj; // or std::shared_ptr<A>obj;
public:
B(std::shared_ptr<A>r) : obj(r) {}
};
int main()
{
std::shared_ptr<A>a(new A());
std::unique_ptr<B>b(new B(a));
我有以下代码
class A {
A(int & r)
: i(r)
{}
A(A&& obj)
: i(obj.i)
{}
operator=(A&& obj)
{
// ?
}
int& i;
}
想象一下下面的主要内容
int main()
{
int r = 12;
int r2 = 21;
A a(r);
A b(r2);
b = std::move(a);
r = 42;
std::cout <<
当变量引用对象时,值是对对象的引用(来自: )
function fun1(obj) {
obj.first = 1; //it affects the object ->obj
}
var myObj1 = {first: 0};
fun1(myObj1); //sending the object to the function
console.log(myObj1.first); // 1
但是,我想从一个对象中更改变量,例如
function fun2(obj) {
obj = 1; }
var myObj2 = {first: 0};
fun2(myObj2.firs