精华内容
下载资源
问答
  • 拾取一个构件,取得引用的方式 FamilyInstance instance = doc.GetElement(uiDoc.Selection.PickObject(ObjectType.Element, “Select”)) as FamilyInstance; IList refFB = instance.GetReferences...

    拾取一个构件,取得引用的方式

    FamilyInstance instance = doc.GetElement(uiDoc.Selection.PickObject(ObjectType.Element, "Select")) as FamilyInstance;
     IList<Reference> refFB =	instance.GetReferences(FamilyInstanceReferenceType.CenterFrontBack);
      IList<Reference> refLR =	instance.GetReferences(FamilyInstanceReferenceType.CenterLeftRight);
    
    展开全文
  • Java篇 - 四种引用(Reference)实战

    万次阅读 多人点赞 2019-01-16 18:49:35
    Java的垃圾回收(GC)是虚拟机自动管理的,...Java对象的引用包括:强引用,软引用,弱引用,虚引用,Java中提供这四种引用类型主要有两个目的: 可以让程序员通过代码的方式决定某些对象的生命周期。 有利于JVM...

     

    Java的垃圾回收(GC)是虚拟机自动管理的,前面我有篇文章专门讲GC:《JVM篇 - GC给你整明白》

    Java内存管理分为内存分配和内存回收,都不需要程序员负责,垃圾回收的机制主要是看对象是否有引用指向该对象。

    Java对象的引用包括:强引用,软引用,弱引用,虚引用,Java中提供这四种引用类型主要有两个目的:

    • 可以让程序员通过代码的方式决定某些对象的生命周期。
    • 有利于JVM进行垃圾回收。

     

    目录:

    1. 强引用(StrongReference)
    2. 软引用(SoftReference)
    3. 弱引用(WeakReference)
    4. 虚引用(PhantomReference)
    5. 引用队列(ReferenceQueue)

     

     

    1. 强引用(StrongReference)

     

    • 1.1 概念

    强引用是指创建一个对象并它赋值给一个引用,引用是存在JVM中的栈中的。

    例如:

        private static void testStrongReference() {
            Object object = new Object();
            Object[] objects = new Object[1000];
        }

    可以看到,testStrongReference()方法中,创建了一个对象和一个对象数组,当testStrongReference()执行完,JVM会自动回收它们(属于局部变量)。但是因为它们都是强引用,所以当执行到testStrongRefenerce()时,如果内存不足,不足够在堆中分配这些内存,那么JVM将抛出OutOfMemory,因为强引用的对象,只要有引用变量指向它们的时候,它们将不会被垃圾回收。

    如果想中断强引用和某个对象之间的关联,可以显示地将引用赋值为null,这样一来的话,JVM在合适的时间就会回收该对象。

     

    • 1.2 例子

    看看Vector类的清理方法:

        protected Object[] elementData;
        
        public synchronized void removeAllElements() {
            modCount++;
            // Let gc do its work
            for (int i = 0; i < elementCount; i++)
                elementData[i] = null;
    
            elementCount = 0;
        }

    在清除数据的时候,将数组中的每个元素都置为null,中断强引用与对象之间的关系,让GC的时候能够回收这些对象的内存。

     

     

     

    2. 软引用(SoftReference)

    我做Android时,第一次接触引用这个概念就是从软引用开始的,那是13年的时候,当时还没有那么多的第三方图片加载框架,图片加载都得自己写。当时的实现方法中,内存中缓存的Bitmap使用的就是软引用。

     

    • 2.1 概念

    如果一个对象具有软引用,只要内存空间足够,垃圾回收器就不会回收它。如果内存空间不足了,就会回收这些对象的内存。只要垃圾回收器没有回收它,该对象就可以被程序使用。

    软引用可用来实现内存敏感的高速缓存,比如网页缓存、图片缓存等。使用软引用能防止内存泄露,增强程序的健壮性。   
    SoftReference的特点是它的一个实例保存对一个Java对象的软引用, 该软引用的存在不妨碍垃圾收集线程对该Java对象的回收。也就是说,一旦SoftReference保存了对一个Java对象的软引用后,在垃圾线程对这个Java对象回收前,SoftReference类所提供的get()方法返回Java对象的强引用。一旦垃圾线程回收该Java对象之 后,get()方法将返回null。

     

    • 2.2 例子

    分享一个平时开发中的例子,就是上面说的图片缓存。

    public class ImageMemoryCache {
    	/**
    	 * 从内存读取数据速度是最快的,为了更大限度使用内存,这里使用了两层缓存。 硬引用缓存不会轻易被回收,用来保存常用数据,不常用的转入软引用缓存。
    	 */
    	private static final int SOFT_CACHE_SIZE = 20; // 软引用缓存容量
    	private static LruCache<String, Bitmap> mLruCache; // 硬引用缓存
    	private static LinkedHashMap<String, SoftReference<Bitmap>> mSoftCache; // 软引用缓存
    
    	public ImageMemoryCache(Context context) {
    		int memClass = ((ActivityManager) context.getSystemService(Context.ACTIVITY_SERVICE)).getMemoryClass();
    		int cacheSize = 1024 * 1024 * memClass / 4; // 硬引用缓存容量,为系统可用内存的1/4
    		mLruCache = new LruCache<String, Bitmap>(cacheSize) {
    			@Override
    			protected int sizeOf(String key, Bitmap value) {
    				if (value != null)
    					return value.getRowBytes() * value.getHeight();
    				else
    					return 0;
    			}
    
    			@Override
    			protected void entryRemoved(boolean evicted, String key, Bitmap oldValue, Bitmap newValue) {
    				if (oldValue != null)
    					// 硬引用缓存容量满的时候,会根据LRU算法把最近没有被使用的图片转入此软引用缓存
    					mSoftCache.put(key, new SoftReference<Bitmap>(oldValue));
    			}
    		};
    		mSoftCache = new LinkedHashMap<String, SoftReference<Bitmap>>(SOFT_CACHE_SIZE, 0.75f, true) {
    			private static final long serialVersionUID = 6040103833179403725L;
    
    			@Override
    			protected boolean removeEldestEntry(Entry<String, SoftReference<Bitmap>> eldest) {
    				if (size() > SOFT_CACHE_SIZE) {
    					return true;
    				}
    				return false;
    			}
    		};
    	}
    
    	/**
    	 * 从缓存中获取图片
    	 */
    	public Bitmap getBitmapFromCache(String url) {
    		Bitmap bitmap;
    		// 先从硬引用缓存中获取
    		synchronized (mLruCache) {
    			bitmap = mLruCache.get(url);
    			if (bitmap != null) {
    				// 如果找到的话,把元素移到LinkedHashMap的最前面,从而保证在LRU算法中是最后被删除
    				mLruCache.remove(url);
    				mLruCache.put(url, bitmap);
    				return bitmap;
    			}
    		}
    		// 如果硬引用缓存中找不到,到软引用缓存中找
    		synchronized (mSoftCache) {
    			SoftReference<Bitmap> bitmapReference = mSoftCache.get(url);
    			if (bitmapReference != null) {
    				bitmap = bitmapReference.get();
    				if (bitmap != null) {
    					// 将图片移回硬缓存
    					mLruCache.put(url, bitmap);
    					mSoftCache.remove(url);
    					return bitmap;
    				} else {
    					mSoftCache.remove(url);
    				}
    			}
    		}
    		return null;
    	}
    
    	/**
    	 * 添加图片到缓存
    	 */
    	public void addBitmapToCache(String url, Bitmap bitmap) {
    		if (bitmap != null) {
    			synchronized (mLruCache) {
    				mLruCache.put(url, bitmap);
    			}
    		}
    	}
    	
    	public void removeBitmap(String url) {
    		if (url != null) {
    			synchronized (mLruCache) {
    				mLruCache.remove(url);
    			}
    			synchronized (mSoftCache) {
    				mSoftCache.remove(url);
    			}
    		}
    	}
    
    	public void clearCache() {
    		mSoftCache.clear();
    	}
    }
    

     

     

     

    3. 弱引用(WeakReference)

     

    • 3.1 概念

    弱引用也是用来描述非必需对象的,当JVM进行垃圾回收时,无论内存是否充足,都会回收被弱引用关联的对象。其实,上面图片缓存的框架用弱引用也可以做,特别是在移动设备上,内存容量有限。

     

    • 3.2 例子

    还是以平时开发中遇到的问题为例:

    (1) Handler内存泄漏问题

    Android中使用Handler可以实现在不同线程间通信,如果在Activity界面使用Handler,由于Handler的机制(这边就不细说),当Activity退出后,处理不当,Handler会一直持有该Activity的引用,那引起的内存泄漏是很大的。如何解决呢?

    private static class NoLeakHandler extends Handler{
    
            private WeakReference<Activity> mActivityRef;
    
            public NoLeakHandler(Activity activity){
                mActivityRef = new WeakReference<>(activity);
            }
    
            @Override
            public void handleMessage(Message msg) {
                super.handleMessage(msg);
                if (mActivityRef.get() != null) {
                     // 处理相应的逻辑
                }
            }
        }
    }

    使用静态内部类(脱离外部类引用的限制) + 弱引用的方式解决这种内存泄漏的问题。当然解决源头还是在Activity退出的时候,移除Handler内部消息队列的数据。

     

    (2) ViewPager适配器

    Android中的ViewPager + Fragment是很多项目界面采用的组合,但是Fragment用的不好,性能上会相差很大,造成内存占用大,卡顿的问题。我一般会这么写ViewPager的适配器:

        private static final class TabPagerAdapter extends FragmentPagerAdapter {
    
            private final WeakReference<Fragment>[] data;
    
            @SuppressWarnings("unchecked")
            TabPagerAdapter(FragmentManager fm) {
                super(fm);
                data = (WeakReference<Fragment>[]) Array.newInstance(WeakReference.class, getCount());
            }
    
            @Override
            public Fragment getItem(int position) {
                if (position < 0 || position >= getCount()) {
                    return new Fragment();
                }
                Fragment f = null;
                if (!Requires.isNull(data[position])) {
                    f = data[position].get();
                } else {
                    if (position == 0) {
                        f = HomeFragment.newInstance();
                    } else if (position == 1) {
                        f = DappFragment.newInstance();
                    } else if (position == 2) {
                        f = SettingsFragment.newInstance();
                    }
                    data[position] = new WeakReference<>(f);
                }
                return f;
            }
    
            @Override
            public int getCount() {
                return 3;
            }
        }

    第一是懒加载方式,滑动到某个界面的时候,再构造对应的Fragment,同时Fragment使用弱引用包装。

     

     

     

    4. 虚引用(PhantomReference)

     

    4.1 概念

    虚引用和前面的软引用、弱引用不同,它并不影响对象的生命周期。如果一个对象与虚引用关联,则跟没有引用与之关联一样,在任何时候都可能被垃圾回收器回收。

    要注意的是,虚引用必须和引用队列关联使用,当垃圾回收器准备回收一个对象时,如果发现它还有虚引用,就会把这个虚引用加入到与之关联的引用队列中。程序可以通过判断引用队列中是否已经加入了虚引用,来了解被引用的对象是否将要被垃圾回收。如果程序发现某个虚引用已经被加入到引用队列,那么就可以在所引用的对象的内存被回收之前采取必要的行动。

     

    4.2 例子

        public static void main(String[] args) {
            Object object = new Object();
            ReferenceQueue<Object> referenceQueue = new ReferenceQueue<>();
            PhantomReference<Object> phantomReference = new PhantomReference<>(object, referenceQueue);
            // 一直返回null,PhantomReference的get()结果必定为null
            System.out.println("phantomReference.get() = " + phantomReference.get());
            Reference<?> reference;
            while ((reference = referenceQueue.poll()) != null) {
                if (reference.equals(phantomReference)) {
                    System.out.println("被回收了");
                }
            }
        }

    注意:PhantomReference的get()结果必定为null。

     

     

     

    5. 引用队列(ReferenceQueue)

     

    • 5.1 概念

    上面在虚引用中说到了引用队列,再举个例子,作为一个Java对象,SoftReference对象除了具有保存软引用的特殊性之外,也具有Java对象的一般性。所以,当软可及对象被回收之后,虽然这个SoftReference对象的get()方法返回null,但这个SoftReference对象已经不再具有存在的价值,需要一个适当的清除机制,避免大量SoftReference对象带来的内存泄漏。在java.lang.ref包里还提供了ReferenceQueue。如果在创建SoftReference对象的时候,使用了一个ReferenceQueue对象作为参数提供给SoftReference的构造方法:

    ReferenceQueue queue = new ReferenceQueue();  
    SoftReference  ref = new SoftReference(object, queue);  

    那么当这个SoftReference所软引用的对象被垃圾收集器回收的同时,ref所强引用的SoftReference对象被列入ReferenceQueue。也就是说,ReferenceQueue中保存的对象是Reference对象,而且是已经失去了它所软引用的对象的Reference对象。另外从ReferenceQueue这个名字也可以看出,它是一个队列,当我们调用它的poll()方法的时候,如果这个队列中不是空队列,那么将返回队列前面的那个Reference对象。

    在任何时候,我们都可以调用ReferenceQueue的poll()方法来检查是否有它所关心的非强可及对象被回收。如果队列为空,将返回一个null,否则该方法返回队列中前面的一个Reference对象。利用这个方法,我们可以检查哪个SoftReference所软引用的对象已经被回收,于是我们可以把这些失去所软引用的对象的SoftReference对象清除掉。

    SoftReference ref = null;
    while ((ref = (EmployeeRef) q.poll()) != null) {
        // 清除ref
    }

    再来看看几种引用的源码定义:

    public class SoftReference<T> extends Reference<T> {
    
        static private long clock;
    
        private long timestamp;
    
        public SoftReference(T referent) {
            super(referent);
            this.timestamp = clock;
        }
    
        public SoftReference(T referent, ReferenceQueue<? super T> q) {
            super(referent, q);
            this.timestamp = clock;
        }
    
        public T get() {
            T o = super.get();
            if (o != null && this.timestamp != clock)
                this.timestamp = clock;
            return o;
        }
    }
    public class WeakReference<T> extends Reference<T> {
    
        public WeakReference(T referent) {
            super(referent);
        }
    
        public WeakReference(T referent, ReferenceQueue<? super T> q) {
            super(referent, q);
        }
    }
    public class PhantomReference<T> extends Reference<T> {
            
        // get()只会返回null
        public T get() {
            return null;
        }
    
        public PhantomReference(T referent, ReferenceQueue<? super T> q) {
            super(referent, q);
        }
    }

    可以看到,几种引用都提供了传入引用队列的构造器。

     

    • Reference类
    public abstract class Reference<T> {
    
        private T referent;
    
        volatile ReferenceQueue<? super T> queue;
    
        @SuppressWarnings("rawtypes")
        Reference next;
    
        transient private Reference<T> discovered; 
    
        static private class Lock { }
        private static Lock lock = new Lock();
    
        private static Reference<Object> pending = null;
    
        private static class ReferenceHandler extends Thread {
    
            private static void ensureClassInitialized(Class<?> clazz) {
                try {
                    Class.forName(clazz.getName(), true, clazz.getClassLoader());
                } catch (ClassNotFoundException e) {
                    throw (Error) new NoClassDefFoundError(e.getMessage()).initCause(e);
                }
            }
    
            static {
                ensureClassInitialized(InterruptedException.class);
                ensureClassInitialized(Cleaner.class);
            }
    
            ReferenceHandler(ThreadGroup g, String name) {
                super(g, name);
            }
    
            public void run() {
                while (true) {
                    tryHandlePending(true);
                }
            }
        }
    
        static boolean tryHandlePending(boolean waitForNotify) {
            Reference<Object> r;
            Cleaner c;
            try {
                synchronized (lock) {
                    if (pending != null) {
                        r = pending;
                        c = r instanceof Cleaner ? (Cleaner) r : null;
                        pending = r.discovered;
                        r.discovered = null;
                    } else {
                        if (waitForNotify) {
                            lock.wait();
                        }
                        return waitForNotify;
                    }
                }
            } catch (OutOfMemoryError x) {
                Thread.yield();
                return true;
            } catch (InterruptedException x) {
                return true;
            }
    
            if (c != null) {
                c.clean();
                return true;
            }
    
            ReferenceQueue<? super Object> q = r.queue;
            if (q != ReferenceQueue.NULL) q.enqueue(r);
            return true;
        }
    
        static {
            ThreadGroup tg = Thread.currentThread().getThreadGroup();
            for (ThreadGroup tgn = tg;
                 tgn != null;
                 tg = tgn, tgn = tg.getParent());
            Thread handler = new ReferenceHandler(tg, "Reference Handler");
            handler.setPriority(Thread.MAX_PRIORITY);
            handler.setDaemon(true);
            handler.start();
    
            SharedSecrets.setJavaLangRefAccess(new JavaLangRefAccess() {
                @Override
                public boolean tryHandlePendingReference() {
                    return tryHandlePending(false);
                }
            });
        }
    
        public T get() {
            return this.referent;
        }
    
        public void clear() {
            this.referent = null;
        }
    
        public boolean isEnqueued() {
            return (this.queue == ReferenceQueue.ENQUEUED);
        }
    
        public boolean enqueue() {
            return this.queue.enqueue(this);
        }
    
        Reference(T referent) {
            this(referent, null);
        }
    
        Reference(T referent, ReferenceQueue<? super T> queue) {
            this.referent = referent;
            this.queue = (queue == null) ? ReferenceQueue.NULL : queue;
        }
    }

    大致解释下:

    Reference主要是负责内存的一个状态,当然它还和java虚拟机,垃圾回收器打交道。Reference类首先把内存分为4种状态Active,Pending,Enqueued,Inactive。

    • 一般来说内存一开始被分配的状态都是Active。
    • Pending是指快要被放进队列的对象,也就是马上要回收的对象。
    • Enqueued就是对象的内存已经被回收了,我们已经把这个对象放入到一个队列中,方便以后我们查询某个对象是否被回收。
    • Inactive就是最终的状态,不能再变为其它状态。

    几个变量:

    • referent表示其引用的对象,即在构造的时候需要被包装在其中的对象。
    • queue是对象即将被回收时所要通知的队列。当对象即将被回收时,整个reference对象,而不仅仅是被回收的对象,会被放到queue里面,然后外部程序即可通过监控这个queue即可拿到相应的数据了。
    • next即当前引用节点所存储的下一个即将被处理的节点。但next仅在放到queue中才会有意义,因为只有在enqueue的时候,会将next设置为下一个要处理的Reference对象。为了描述相应的状态值,在放到队列当中后,其queue就不会再引用这个队列了。而是引用一个特殊的 ENQUEUED(内部定义的一个空队列)。因为已经放到队列当中,并且不会再次放到队列当中。
    • discovered表示要处理的对象的下一个对象。即可以理解要处理的对象也是一个链表,通过discovered进行排队,这边只需要不停地拿到pending,然后再通过discovered不断地拿到下一个对象赋值给pending即可,直到取到了最有一个。它是被JVM使用的。
    • pending是等待被入队的引用列表。JVM收集器会添加引用到这个列表,直到Reference-handler线程移除了它们。这个列表使用discovered 字段来连接它下一个元素(即 pending 的下一个元素就是discovered对象。r = pending; pending = r.discovered)。

    当 Refrence类被加载的时候,会执行静态代码块。在静态代码块里面,会启动ReferenceHandler线程,并设置线程的级别为最大级别:Thread.MAX_PRIORITY。

    在 tryHandlePending()方法里面,检查 pending是否为null,如果pending不为null,则将pending进行enqueue,否则线程进入 wait状态。简单来说,垃圾回收器会把 References添加进入,Reference-handler thread会移除它,即discovered和pending 是由垃圾回收器进行赋值的。

     

    总结一下:

    Refrence和引用队列ReferenceQueue联合使用时,如果Refrence持有的对象被垃圾回收,Java虚拟机就会把这个引用加入到与之关联的引用队列中。Android中著名的内存泄漏检测工具LeakCannary就是用这种方式做的,后面的Android第三方库源码分析会有一篇LeakCannary的源码分析。


     

    展开全文
  • C++ 引用Reference

    千次阅读 2019-04-25 17:16:56
    C++ Reference 引用实际上是指针的一个扩展,但是又不同于指针。 首先,引用必须引用一个已经存在的变量。不像指针,指针可以被声明为空指针,但引用不可以。引用本身并不是一个新的变量,它并不实际占用内存空间,...

    C++ Reference


    引用实际上是指针的一个扩展,但是又不同于指针。
    首先,引用必须引用一个已经存在的变量。不像指针,指针可以被声明为空指针,但引用不可以。引用本身并不是一个新的变量,它并不实际占用内存空间,也并不实际储存数据,它仅仅是一个变量的引用。

    举例说明:

    #include <iostream>
    
    #define LOG(x) std::cout << x << std::endl;
    
    int main()
    {
    	int a = 5;
    	int& ref = a;
    	std::cin.get();
    }
    

    在上述代码中,ref 是变量 a 的引用。实际上,ref 相当于变量 a 的别名。 如果将上述代码编译,实际上只会在内存空间中创建一个变量 a。

    如果改变 ref 的值,打印 a:

    #include <iostream>
    
    #define LOG(x) std::cout << x << std::endl;
    
    int main()
    {
    	int a = 5;
    	int& ref = a;
    
    	ref = 2;
    	LOG(a);
    
    	std::cin.get();
    }
    

    则 a 的值也为 2.

    即变量的引用仅仅相当于该变量的别名,并不会重新生成一个变量。

    那么既然仅仅只是给变量起一个别名,什么情况下我们需要用到引用呢?就上述情况而言,我们直接调用变量 a 就可以了,为啥要多写几行代码来创建一个引用呢?

    看下面的例子:

    #include <iostream>
    
    #define LOG(x) std::cout << x << std::endl;
    
    void Increment(int value)
    {
    	value++;
    }
    
    int main()
    {
    	int a = 5;
    	Increment(a);
    	LOG(a);
    
    	std::cin.get();
    }
    

    如果我们想要变量 a 调用 Increment,然后自加 1. 上述代码是无法实现这个结果的 ,实际输出 a 的值仍然为 5。这是因为 将变量 a 传给方法 Increment, 相当于复制该变量到方法里。

    等同于如下效果:

    void Increment(int value)
    {
        int a = 5;
    	value++;
    }
    

    所以并不会改变变量 a 的值。

    那想要达到我们想要的结果,如何做呢?

    首先,当然,指针是可以做到的。指针指向的是变量的内存空间中的地址,即变量实际存在的地方。如果我们直接把变量的地址传给 Increment 函数,那肯定是可以改变该变量的值的,如下所示:

    #include <iostream>
    
    #define LOG(x) std::cout << x << std::endl;
    
    void Increment(int* value)
    {
    	(*value)++;
    }
    
    int main()
    {
    	int a = 5;
    	Increment(&a);
    	LOG(a);
    
    	std::cin.get();
    }
    

    输出结果为 6.

    可以看到,指针确实能得到我们想要的结果。但有没有更简单清晰一点的方法呢?

    #include <iostream>
    
    #define LOG(x) std::cout << x << std::endl;
    
    void Increment(int& value)
    {
    	value++;
    }
    
    int main()
    {
    	int a = 5;
    	Increment(a);
    	LOG(a);
    
    	std::cin.get();
    }
    

    运行结果为 6. 可见引用也可以实现我们的目的,并且让代码看起来更加简洁。

    再看一个例子:

    #include <iostream>
    
    #define LOG(x) std::cout << x << std::endl;
    
    int main()
    {
    	int a = 5;
    	int b = 8; 
    
    	int& ref = a;
    	ref = b;
    
    	LOG(a);
    	LOG(b);
    
    	std::cin.get();
    }
    

    输出结果为 8, 8。 即变量 a 等于 b = 8。 为什么会这样? 因为引用只能被初始化一次,指向一个变量,并且不能够改变。同时,引用在被声明的同时一定要被初始化。当然,指针是可以先指向一个变量,然后指向另一个变量的。

    展开全文
  • Cpp引用Reference-笔记

    千次阅读 2015-03-13 01:46:54
    Cpp引用Reference本文参考此处引用vs指针(References vs Pointers) 引用不能为NULL,必须连结到一个合法的存储位置。 引用必须在创建时就初始化。 引用初始化完成后,不能再改变。 创建引用type var; type &var_...

    Cpp引用Reference

    本文参考此处

    引用vs指针(References vs Pointers)

    • 引用不能为NULL,必须连结到一个合法的存储位置。
    • 引用必须在创建时就初始化。
    • 引用初始化完成后,不能再改变。

    创建引用

    type var;
    type &var_ref = var;  // 引用

    引用作为参数

    void swap(int &x, int &y)
    {
        int temp;
        temp = x;  // save the value at address x
        x = y;     // put y into x
        y = temp;  // put x into y
    }

    引用作为返回值

    当返回值是引用时,可以作左值

    #include <iostream>
    using namespace std;
    
    int arr[5] = {0};
    
    int &setValue(int i)
    {
        return arr[i];  // 返回第i元素的引用
    }
    
    int main()
    {
        setValue(3) = 100;
        int i;
        for (i = 0; i < 5; ++i)
        {
            cout << arr[i] << endl;
        }
        return 0;
    }
    
    // 运行结果
    0
    0
    0
    100
    0    //注意变量的生存期

    展开全文
  • 七、引用(reference)详解

    万次阅读 2017-03-31 20:31:25
    如果reference类型的数据中存储的数值代表的是另外一块内存的起始地址,就称这块内存代表着一个引用引用不等同于对象本身,根据虚拟机种类的不同,可能是一个指向对象起始地址的引用指针,也可能是指向一个代表...
  • reference point
  • reference引用

    2014-07-03 22:40:45
    引用reference代码,其中一部分~
  • IEEE Reference 文献引用格式

    热门讨论 2012-03-23 17:20:23
    IEEE Reference style文献引用格式 适用于word 2007/2010 用法: 解压后,见文件复制到(32/64) C:\Program Files\Microsoft Office\Office 12\Bibliography\Style 重新打开word,就可以正常使用了
  • 先说说引用Reference的一点常识和作用: Revit大量使用引用(Reference)指向一个对象,来指向对象之间的关系,这是Revit能智能更新模型的关键技术。比如对于一个尺寸标注对象Dimension,它保留了对所指向的那些面...
  • 详细描述了IEEE风格论文所采用的各种文献引用方式并有举例,方便研究生学习如何正确引用文献
  • 常见的面试中会有这么一道题,“谈谈强引用、 软引用、 弱引用、虚引用”。  A:强引用,通过new出来的都是强引用  Q:那弱引用呢?  A:通过...  Class Reference  java.lang.Object  java.lan
  • 主要介绍了SpringBoot通过整合Dubbo解决@Reference注解问题,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
  • 当返回函数的零时量的引用的时候就会出现这种情况。 3.cc: In function ‘const string& add_(const string&, const string&, const string&)’: 3.cc:6:12: warning: reference to local variable...
  • 让VSCode支持 "Find all reference

    万次阅读 2018-11-23 09:38:40
     这个插件支持"Peek definition" && "Find all reference" 功能, 但是这个插件有个小bug, 安装完后并不能正常工作。而且作者很长时间没有更新这个插件了,无奈只能自己折腾一番。  找个下面这个文件:  ...
  • c语言中,没有reference的概念。这是c规范中规定。c规范链接? 为什么大家会认为C语言会有引用的概念呢? c++中有引用这个概念,含义是变量的别名。 在cpp文件中,支持以c形式写代码。因而导致大家误认为c支持引用。...
  • 因为这里reference_a是i_temp 的引用,它和i_temp 是共享同一块内存区域,在调用reference_test()函数时,相当于将引用变量的值赋给了i_temp,因此值也就被保留下来了。 因此 ,尽量不要尝试传回引用,可能会存在...
  • 直到查阅到类似情况:https://forums.xilinx.com/t5/Embedded-Development-Tools/SDK-undefined-reference/td-p/818300 发现我的工程的问题是gcc 链接时找不到库文件,如下图我在gcc链接命令中添加了 -llwip4 (该...
  • 1.pointer可以为空,但是reference 不能为空。说明一下几个问题:如果你的变量可能为空,那么你应该将其设计为pointer而不是refrence。反之,如果你的变量不能取空值,那么你应该将其设计为reference。 reference...
  • 在java中,我们知道一般情况下当一个对象被其他对象引用时,该对象则不会被回收。但是有时我们虽然需要使用该对象,但又希望不影响回收。 比如在Activity中以内部类的方式创建了一个Handler,这个Handler就会隐式的...
  • Oracle 11g引用分区reference partition

    千次阅读 2017-09-01 22:40:48
    父表中被引用的主键列不一定要是分区键。   一个例子: 下面是设计分区方案过程中的一个典型问题,并非所有表都需要根据其进行分区的列。假设要创建一个销售系统,该系统包括两个简单的表(sales 和customers)...
  • 引用解析之Reference和ReferenceQueue

    千次阅读 2019-04-12 13:51:58
    (1)强引用 Strong Reference 日常开发中最经常使用的引用类型,例如Object object = new Object()使用的就是强引用。当一个对象的强引用存在,这个对象用于不会被回收。在Java中没有专门的类与之对应。 (2)软...
  • call by reference: 按引用传递 特点: call by value。 不改变值,即操作的是一个值的拷贝,所以原值不变。 call by reference 改变值,但是不改变实际参数的参考地址。可以理解为将另一个引用也指向同一个...
  • 1.一个引用计数(Reference-Counting)基类Reference-counting可用于字符串以外的场合,任何class如果其不同的对象可能拥有相同的值,都适用此技术。但是如果重写class以便适用reference counting可能需要大量的工作...
  • VBA中代码加载引用方法实践  因为excel使用范围广泛,VBA编程极大方便了数据的处理及提供了很好的方便易用的编程环境,但也许你在编程项目处理中经常会遇到这样的情况:编写好的程序有时候在客户的电脑...
  • Java8 MethodReference方法引用

    千次阅读 2017-11-02 11:04:13
    package com.lgx.jdk8.part02; import java.util.Arrays; import java.util.Collections; import java.util.List; import java.util.function.Function;...import java.util.function.Supplier;... * 方法引用的学习 */
  • 引用(Reference)和指针到底有什么区别呢?先写几行C++代码,看看它们生成的汇编。pointer.ccvoid simpleFun(int* a_p){ *a_p = 7;} 其生成的汇编:_Z9simpleFunPi:.LFB2: pushl %ebp.LCFI0: movl %esp, %ebp....
  • reference-link-generator 将markdown文章引用的链接转化为链接列表 将markdown引用链接输入到下面文本框中,自动转换为地址列表格式,方便markdown文章最后添加参考链接。
  • C++ :引用计数(reference count) 实现

    千次阅读 2018-09-19 21:40:01
    referecen count 的核心思维:使用一个计数器来标识当前指针指向的对象被多少类的对象所使用(即记录指针指向对象被引用的次数) 构造函数中创建类的新对象时,初始化引用计数为1; 拷贝构造函数复制指针,并使...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 271,002
精华内容 108,400
关键字:

怎么引用reference