android智能指针详解
android cursorwindow原理
android cursorwindow原理
CursorWindow是Android中用于存储查询结果集的一个基本的数据结构，它是一个二维的表格，类似于数据库中的表。
CursorWindow可以存储大量的数据，而且内存占用较小，性能较高。
CursorWindow的底层实现是一个基于binder机制的内存映射文件，它将查询结果集以二进制的形式存储在内存中。
CursorWindow可以根据需要自动分配和释放内存，以适应不同的查询结果集。
在使用CursorWindow存储查询结果时，首先需要创建一个CursorWindow对象，然后通过调用其各种方法将查询结果集存储到CursorWindow中。
存储完成后，可以通过游标访问内存中存储的数据。
当查询结果集大于CursorWindow当前可用的内存大小时，CursorWindow会自动分配更多的内存。
当不再需要查询结果集时，CursorWindow会自动释放占用的内存。
总之，CursorWindow是一个用于存储和管理查询结果集的数据结构，它通过内存映射文件的方式实现了高效的存储和访问查询结果的功能。
Android中sp与wp的区别与理解
Android中sp与wp的区别与理解Android中定义了两种智能指针类型，一种是强指针sp （strong pointer），另外一种是弱指针（weak pointer）。
其实称之为强引用和弱引用更合适一些。
强指针与一般意义的智能指针概念相同，通过引用计数来记录有多少使用者在使用一个对象，如果所有使用者都放弃了对该对象的引用，则该对象将被自动销毁。
弱指针也指向一个对象，但是弱指针仅仅记录该对象的地址，不能通过弱指针来访问该对象，也就是说不能通过弱智真来调用对象的成员函数或访问对象的成员变量。
要想访问弱指针所指向的对象，需首先通过wp类所提供的promote()方法将弱指针升级为强指针。
弱指针所指向的对象是有可能在其它地方被销毁的，如果对象已经被销毁，wp的promote()方法将返回空指针，这样就能避免出现地址访问错的情况。
弱指针是怎么做到这一点的呢？其实说白了一点也不复杂，原因就在于每一个可以被智能指针引用的对象都同时被附加了另外一个weakref_impl类型的对象，这个对象中负责记录对象的强指针引用计数和弱指针引用计数。
这个对象是智能指针的实现内部使用的，智能指针的使用者看不到这个对象。
弱指针操作的就是这个对象，只有当强引用计数和弱引用计数都为0时，这个对象才会被销毁。
下面介绍下怎么使用，假设现在有一个类MyClass，如果要使用智能指针来引用这个类的对象，那么这个类需满足下列两个前提条件：1：这个类是基类RefBase的子类或间接子类；2：这个类必须定义虚析构造函数，即它的析构函数需要这样定义：virtual ~MyClass();满足了上述条件的类就可以定义为Android智能指针了，定义方法和普通指针类似。
比如普通指针是这样定义：MyClass* p_obj;智能指针是这样定义：sp<MyClass> p_obj;注意不要定义成sp<MyClass>* p_obj，这样其实相当于定义了一个指针的指针。
Android中的sp和wp指针
经常会在 android 的 framework 代码中发现 sp<xxx>和 wp<xxx>这样的指针, 平时看的时候都把他当成一个普通的指针封装过掉了,这几天终于忍不住了,想 深入了解一下。 相关的代码： frameworks/base/include/utils/RefBase.h frameworks/base/libs/utils/RefBase.cpp
view plaincopy to clipboardprint? 1. 2. 3. 4. 5. 6. template<typename T> sp<T>::sp(T* other) : m_ptr(other) { if (other) other->incStrong(this); }
view plain 1. template<typename T> 2. sp<T>::sp(T* other) 3. : m_ptr(other)
4. { 5. if (other) other->incStrong(this); 6. }
建立 sp<xxx>的动态关系如下：
sp<T> --> RefBase : incStrong() -->weakref_impl : addStrongRef() -->android_atomic_inc(&refs->mStrong)
43. return 0; 44.}
程序打印的结果是：
D/sp-wp-sample( D/sp-wp-sample( D/sp-wp-sample( D/sp-wp-sample( D/sp-wp-sample( D/sp-wp-sample( D/sp-wp-sample( D/sp-wp-sample(
android智能指针(wp、sp)学习总结
智能指针：强指针sp，弱指针wp，轻量级指针LightRefBase。
相关文件：RefBase.h，RefBase.cpp，StrongPointer.h(注：参考代码android 4.2.2)。
RefBase.h：定义了RefBase类定义，wp模板类定义和实现，以及LightRefBase类定义。
RefBase.cpp：定义了RefBase类实现以及RefBase的嵌套类weakref_type的实现。
StrongPointer.h：定义了sp模板类定义和实现。
RefBase类主要方法如下：void RefBase::incStrong(const void* id) const{weakref_impl* const refs = mRefs;refs->incWeak(id); // 增加一次弱引用计数refs->addStrongRef(id); // 空函数// 原子操作，增加一次强引用计数，返回的是refs->mStrong执行加1操作之前的值const int32_t c = android_atomic_inc(&refs->mStrong);ALOG_ASSERT(c > 0, "incStrong() called on %p after last strong ref", refs);// 第一次执行，c的值为INITIAL_STRONG_V ALUEif (c != INITIAL_STRONG_V ALUE) {//从第二次开始执行后，此条件都成立，直接返回return;}// 执行操作，refs->mStrong + (-INITIAL_STRONG_V ALUE)，第一次执行后强引用计数refs->mStrong值变为1android_atomic_add(-INITIAL_STRONG_V ALUE, &refs->mStrong);refs->mBase->onFirstRef(); //第一次执行会调用该方法，子类可以覆盖该方法。
android accessibilitynodeinfo详解
android accessibilitynodeinfo详解AccessibilityNodeInfo是Android中的一个类，用于描述应用程序界面中的可访问节点信息。
它提供了一系列方法，用于获取和设置节点的各种属性和状态，以及与节点进行交互的方法。
AccessibilityNodeInfo的详细解释如下：1. 节点类型：AccessibilityNodeInfo提供了获取节点类型的方法，可以判断节点是什么类型的控件，比如按钮、文本框、复选框等。
通过节点类型，可以根据需要进行相应的操作。
2. 节点文本：AccessibilityNodeInfo提供了获取节点文本的方法，可以获取控件上显示的文本内容。
这对于需要读取或验证控件上的文本信息非常有用。
3. 节点状态：AccessibilityNodeInfo提供了获取节点状态的方法，可以获取控件的状态信息，比如是否可用、是否已选中等。
通过节点状态，可以根据需要进行相应的操作或判断。
4. 节点属性：AccessibilityNodeInfo提供了获取节点属性的方法，可以获取控件的各种属性，比如控件的位置、大小、背景颜色等。
通过节点属性，可以对控件进行定位或判断。
5. 节点操作：AccessibilityNodeInfo提供了一系列方法，用于与节点进行交互，比如点击、长按、滑动等。
通过这些方法，可以模拟用户的操作，实现对控件的操作。
6. 节点关系：AccessibilityNodeInfo提供了获取节点关系的方法，可以获取控件的父节点、子节点、兄弟节点等。
通过节点关系，可以在应用程序界面中进行节点的遍历和查找。
总之，AccessibilityNodeInfo是一个非常重要的类，它提供了丰富的方法和属性，可以帮助开发者实现对应用程序界面中的可访问节点进行获取、操作和判断等功能。
通过使用AccessibilityNodeInfo，可以使Android应用程序更加易于访问和使用。
retrofitretrofit原理面试，字节跳动Android面试凉凉经，学习路线+知识点梳理
retrofitretrofit原理⾯试，字节跳动Android⾯试凉凉经，学习路线+知识点梳理⼤家好！给⼤家介绍⼀下，这是我们持续更新整理的2019-2021字节跳动历年Android⾯试真题解析！早在2019年我们就建了第⼀个字节跳动的⾯试群给⼤家讨论⾯试的东西。
期间累计有1825个群友分享了⾃⼰的Android⾯试真经，并提供了参考答案。
这其中就有很多成员已经斩获今⽇头条、抖⾳等岗位的offer。
有很多成员⾯试虽然失败了，但也分享了很多失败的经验教训。
在这⾥⼀并对他们表⽰感谢！正是因为⼤家的奉献和⽀持，让我们的这份⾯试真题解析已经累计下载1082万次！⾯试官：说⼀下垃圾回收机制吧我： ...可以通过强、弱引⽤计数结合⽅式解决引⽤计数的循环引⽤问题，实际上 Android 的智能指针就是这样实现的...智能指针智能指针在整个 Android ⼯程中使⽤很⼴泛，在 binder 相关源码可以看到 sp、wp 类型的引⽤：sp<IBinder> result = new BpBinder(handle);wp<IBinder> result = new BpBinder(handle);sp 即 strong pointer 强指针引⽤；wp 是 weak pointer 弱指针引⽤。
在 Java 中我们不⽤关⼼对象的销毁及内存释放，GC 机制会⾃动辨别回收⽆⽤对象，⽽智能指针就是 native 层⼀个⼩型的 GC 实现。
智能指针以引⽤计数的⽅式来标识⽆⽤对象，使⽤智能指针的对象需继承⾃ RefBase，RefBase 中维护了此对象的强引⽤数量和弱引⽤数量。
强指针 sp 重载了 "=" 运算符，在引⽤其他对象时将强引⽤计数 +1，在 sp 析构函数中将强引⽤计数 -1，当强引⽤计数减⾄ 0 时销毁引⽤的对象，这样就实现了对象的⾃动释放。
弱指针引⽤其他对象时将弱引⽤计数 +1，在 wp 析构函数中将弱引⽤计数 -1，当强引⽤计数为 0 时，不论弱引⽤计数是否为 0 都销毁引⽤的对象。
unique ptr 原理
unique ptr 原理Unique Ptr: 一种更安全的内存管理方式Unique Ptr是C++11中的一种非常优秀的内存管理方式，它通常用于管理动态分配的内存。
在使用Unique Ptr时，可以避免意外的内存泄漏和悬空指针，使程序更加稳健和安全。
本文主要介绍Unique Ptr的原理和使用方法。
一、 Unique Ptr的原理Unique Ptr是智能指针的一种，它借助 RAII（Resource Acquisition Is Initialization）技术来管理动态分配的内存。
RAII的核心思想是：对象的生命周期应该与它所占有的资源的生命周期相同，即在构造函数中占有资源，在析构函数中释放资源。
Unique Ptr正是利用了这一点，将动态分配的内存封装在一个对象中，当该对象被销毁时，自动释放所占有的资源。
下面是一个示例代码：```#include <memory>void foo(){std::unique_ptr<int> p(new int(1)); // 分配一个整型并占有它// 内存分配成功，p不为空指针// ...} // p离开作用域，析构函数自动释放内存```在上面的代码中，我们创建了一个名为p的Unique Ptr，用来占有分配的整型内存。
当p超出作用域时，会自动调用析构函数来释放所占有的内存。
这样就避免了手动释放内存的繁琐和容易出错的问题。
当然，Unique Ptr还提供了一些其他的操作，以方便内存的使用。
例如，可以使用get()函数来获取指向占有对象的原始指针，而release()函数可以释放对对象的占有权，将其转移给其他的UniquePtr进行管理。
二、 Unique Ptr的使用方法在使用Unique Ptr时，需要注意以下几点：1. 尽量使用make_unique()函数make_unique()函数是Unique Ptr的推荐使用方式。
将智能指针变量 存储到数组中的方法
智能指针是C++语言中一种非常重要的数据类型，它可以帮助程序员管理动态内存分配，并且能够自动释放内存，有效避免内存泄漏的问题。
在实际的编程工作中，有时我们会需要将智能指针变量存储到数组中，以便于对多个指针进行统一管理和操作。
本文将介绍如何将智能指针变量存储到数组中的方法。
1. 使用std::vectorstd::vector是C++标准库中的一个容器类模板，它可以存储各种类型的数据，并且能够动态调整大小。
我们可以利用std::vector来存储智能指针变量，实现对多个指针的统一管理。
我们需要包含< vector>头文件：```cpp#include <vector>```我们定义一个std::vector对象，存储智能指针变量：```cppstd::vector<std::shared_ptr<int>> ptrArray;```在这个例子中，我们使用了std::shared_ptr作为智能指针的类型，存储了int类型的数据。
当然，你也可以选择其他类型的智能指针，如std::unique_ptr或者std::weak_ptr，根据实际情况来选择。
接下来，我们可以向ptrArray中添加智能指针变量：```cppptrArray.push_back(std::make_shared<int>(10));ptrArray.push_back(std::make_shared<int>(20));```通过调用push_back方法，我们可以将智能指针变量添加到ptrArray 中。
这样，我们就实现了将多个智能指针变量存储到数组中的目的。
2. 使用普通指针数组除了使用std::vector外，我们还可以使用普通指针数组来存储智能指针变量。
在实际编程中，这种方法可能会更加高效。
我们定义一个指针数组：```cppstd::shared_ptr<int>* ptrArray = new std::shared_ptr<int>[10]; ```在这个例子中，我们定义了一个含有10个std::shared_ptr<int>类型的指针数组。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
研究Android的时候，经常会遇到sp、wp的东西，网上一搜，原来是android封装了c++中对象回收机制。
说明：1. 如果一个类想使用智能指针，那么必须满足下面两个条件：a. 该类是虚基类RefBase的子类或间接子类b. 该类必须定义虚构造函数。
如virtual ~MyClass();2. 本文以类BBinder来进行说明，其余类使用sp或wp的情况类似3. 代码路径：frameworks/base/libs/utils/RefBase.cppframeworks/base/include/utils/RefBase.h一、calss BBinder类说明class RefBaseclass IBinderclass BpBinder class BBinderclass BBinder : public IBinder{...protected:virtual ~BBinder();...}class IBinder : public virtual RefBase{...protected:inline virtual ~IBinder() { }...}由上，可以看出BBinder和IBinder都是以public的方式继承于虚基类RefBase的。
二、sp wp对象的建立过程解析：sp<BBinder> BB_ptr(new BBinder);这是一条定义sp指针BB_ptr的语句，他只想的对象是一个BBinder对象。
如图所示。
1》首先看一下new BBinder时都做了什么，特别是和该机制相关的初始化。
c++中创建一个对象时，需要调用去构造函数，对于继承类，则是先调用其父类的构造函数，然后才会调用本身的构造函数。
这里new一个BBinder对象时，顺序调用了：RefBase::RefBase() : mRefs(new weakref_impl(this)) {}inline IBinder() {}BBinder::BBinder() : mExtras(NULL){}主要关注的是RefBase的构造函数，可以看出他是通过new weakref_impl(this)的结果来初始化私有成员mRefs这里的this指向BBinder对象自身，class weakref_impl继承于类RefBase的内嵌类weakref_type，然后该类weakref_impl又被类RefBase引用。
类weakref_impl的构造函数如下：weakref_impl(RefBase* base): mStrong(INITIAL_STRONG_VALUE) // 1 << 28, mWeak(0), mBase(base) // new BBinder指针, mFlags(0), mStrongRefs(NULL) // sp引用链表指针, mWeakRefs(NULL) // wp引用链表指针, mTrackEnabled(!!DEBUG_REFS_ENABLED_BY_DEFAULT) // 1, mRetain(false) {}2》new BBinder返回的是BBinder对象的指针，如：sp<BBinder> BB_ptr(0x????????);sp实际上是一个类模板，这条语句最终是要建立一个sp的实例化对象，叫模板类BB_ptr这里生成BB_ptr对象所调用的构造函数是：template<typename T>sp<T>::sp(T* other): m_ptr(other){if (other) other->incStrong(this);}BB_ptr对象的私有指针指向刚刚前面生成的BBinder对象。
接着调用函数incStrong(),该函数是RefBase类的成员函数，在子类中没有被重载，所以这里other->incStrong(this)的调用实际上是调用基类成员函数incStrong(this)，这个this值是指向sp对象 BB_ptr的指针。
现在转去查看该成员函数的实现。
void RefBase::incStrong(const void* id) const{weakref_impl* const refs = mRefs;/* 取得BBinder对象基类中的私有只读指针mRefs */refs->addWeakRef(id);/* 调用weakref_impl类定义时实现的成员函数addWeakRef，见下注释1*/refs->incWeak(id);/* 调用weakref_impl类的基类weakref_type成员函数incWeak，见下注释2*/refs->addStrongRef(id);// 调用weakref_impl类定义时实现的成员函数addStrongRef，见下注释1const int32_t c = Android_atomic_inc(&refs->mStrong);/* 该函数实际将refs->mStrong值加1，也就是增加强引用计数值。
但是返回值为refs->mStrong-1 */LOG_ASSERT(c > 0, "incStrong() called on %p after last strong ref", refs);#if PRINT_REFSLOGD("incStrong of %p from %p: cnt=%d\n", this, id, c);#endifif (c != INITIAL_STRONG_VALUE) {return;}/* c = INITIAL_STRONG_VALUE, 第一个强引用产生的时候才会出现这个情况*/ Android_atomic_add(-INITIAL_STRONG_VALUE, &refs->mStrong);/* 返回值为INITIAL_STRONG_VALUE，refs->mStrong值变成1 */const_cast<RefBase*>(this)->onFirstRef();}/************************注释1********************************/void addWeakRef(const void* id){addRef(&mWeakRefs, id, mWeak);}void addStrongRef(const void* id){addRef(&mStrongRefs, id, mStrong);}addRef()是类weakref_impl的私有成员函数，addWeakRef()函数引用的是public成员变量，而addRef()函数可以操作私有数据。
struct ref_entry{ref_entry* next;const void* id;int32_t ref;};void addRef(ref_entry** refs, const void* id, int32_t mRef){if (mTrackEnabled) {AutoMutex _l(mMutex);ref_entry* ref = new ref_entry;ref->ref = mRef;ref->id = id;ref->next = *refs;*refs = ref;/*新出现的ref_entry结构体加入到链表头上，如果有n个sp指针指向同一个目标对象那么这里就有n个ref_entry结构体加入到这个单链表中，该结构体记录着如下数据1. id域记录着对应的sp强指针类对象的this值2. ref域记录的是当前sp强指针类对象是第几个引用目标对象的指针3. next域指向下一个指向目标对象的sp强指针对应的ref_entry结构体类RefBase的嵌套类weakref_type的子类的私有数据mRefs的私有二级指针成员mWeakRefs指向的是最后一个sp强指针对应的ref_entry结构体指针。
总结一下:一个目标对象，可能被n个sp强指针指向，那么就存在n个class sp对象，同时每一个sp对象在目标对象的虚基类对象的成员类mRefs的私有二级指针成员mWeakRefs登记了一个ref_entry结构体，这些ref_entry结构体的地址都是由该链表管理，每一个ref_entry结构体和哪一个sp对象对应，也由该链表管理。
同时链接数就是该链表节点的个数*/}}/************************注释1********************************//************************注释2********************************/void RefBase::weakref_type::incWeak(const void* id){weakref_impl* const impl = static_cast<weakref_impl*>(this);// 强制类型转换，将基类指针转换成子类指针impl->addWeakRef(id);// 调用类weakref_impl成员函数addWeakRef()，产生一个ref_entry结构体挂载mWeakRefs链表上const int32_t c = Android_atomic_inc(&impl->mWeak);/* impl->mWeak加1，表示已存在一个weak引用。
但返回值c为操作前的结果*/ LOG_ASSERT(c >= 0, "incWeak called on %p after last weak ref", this);}/************************注释2********************************/3》上面是定义一个sp指针，下面看看定义一个wp指针式如何实现的。
wp<BBinder> BB_wp_ptr(BB_ptr);下面是wp类对应上面定义类型的构造函数template<typename T>wp<T>::wp(const sp<T>& other): m_ptr(other.m_ptr){if (m_ptr) {m_refs = m_ptr->createWeak(this);}}this指针是指向wp对象的。