iOS 类的扩展&关联对象

前言

在之前的文章中，我们已经分析了分类的本质和加载原理，不熟悉的同学可以查阅iOS-类的加载（下），那么接下来我们探索一下类拓展以及关联对象的底层实现原理，毕竟面试的时候经常会问我们类扩展和分类的区别....

类扩展 与 分类 的区别

1. category 类别、分类

  • 专门用来给类添加新的方法
  • 不能给类添加成员属性，添加了成员属性，也无法取到
  • 注意：其实可以通过runtime给分类添加属性，即属性关联，重写setter、getter方法
  • 分类中用@property定义变量，只会生成变量的setter、getter方法的声明，不能生成方法实现 和带下划线的成员变量（在分类用@property声明属性，用本类能够赋值，就是因为生成了getter,setter声明，但是由于没有实现，会导致崩溃）

2. extension 类扩展

  • 可以说成是特殊的分类 ，也可称作匿名分类
  • 可以给类添加成员属性，但是是私有变量
  • 可以给类添加方法，也是私有方法

类扩展底层原理探索

通常在创建工程中时会有一个ViewController类或者创建自定义的UIViewController子类的时候，Xcode会在类中自动创建一个类扩展，如图：

ViewController的类扩展

我们经常把不想暴露的一些属性定义在这里，需要外部调用的属性写在.h文件中。

需要注意类扩展有一个位置要求，必须写在类的interface和implementation之间。

clang探索类扩展本质

我们在main.m文件中建一个ZGTercher类扩展

@interface ZGTercher : NSObject
@property (nonatomic, copy) NSString *zg_name;
@property (nonatomic, assign) int zg_age;

- (void)zg_instanceMethod1;
- (void)zg_instanceMethod2;
- (void)zg_instanceMethod3;

+ (void)zg_sayClassMethod;

@end

@implementation ZGTercher


- (void)zg_instanceMethod3{
    NSLog(@"%s",__func__);
}

- (void)zg_instanceMethod1{
    NSLog(@"%s",__func__);
}

- (void)zg_instanceMethod2{
    NSLog(@"%s",__func__);
}


+ (void)zg_sayClassMethod{
    NSLog(@"%s",__func__);
}

@end

int main(int argc, const char * argv[]) {
    @autoreleasepool {

        // insert code here...
//        ZGPerson *person = [ZGPerson alloc];
//        [person zg_instanceMethod1];
    }
    return 0;
}

通过clang -rewrite-objc main.m -o main.cpp命令生成cpp文件，打开cpp文件，搜索我们定义的zg_name属性

typedef struct objc_object ZGTercher;
typedef struct {} _objc_exc_ZGTercher;
#endif

extern "C" unsigned long OBJC_IVAR_$_ZGTercher$_zg_name;//下划线属性
extern "C" unsigned long OBJC_IVAR_$_ZGTercher$_zg_age;
struct ZGTercher_IMPL {
    struct NSObject_IMPL NSObject_IVARS;
    int _zg_age;
    NSString *_zg_name;
};

// @property (nonatomic, copy) NSString *zg_name;
// @property (nonatomic, assign) int zg_age;

// - (void)zg_instanceMethod1;
// - (void)zg_instanceMethod2;
// - (void)zg_instanceMethod3;

// + (void)zg_sayClassMethod;

/* @end */


// @implementation ZGTercher



static void _I_ZGTercher_zg_instanceMethod3(ZGTercher * self, SEL _cmd) {
    NSLog((NSString *)&__NSConstantStringImpl__var_folders_3q_sv9blc555sb1tfw4cl4wgl2h0000gn_T_main_b46ba9_mii_0,__func__);
}


static void _I_ZGTercher_zg_instanceMethod1(ZGTercher * self, SEL _cmd) {
    NSLog((NSString *)&__NSConstantStringImpl__var_folders_3q_sv9blc555sb1tfw4cl4wgl2h0000gn_T_main_b46ba9_mii_1,__func__);
}


static void _I_ZGTercher_zg_instanceMethod2(ZGTercher * self, SEL _cmd) {
    NSLog((NSString *)&__NSConstantStringImpl__var_folders_3q_sv9blc555sb1tfw4cl4wgl2h0000gn_T_main_b46ba9_mii_2,__func__);
}



static void _C_ZGTercher_zg_sayClassMethod(Class self, SEL _cmd) {
    NSLog((NSString *)&__NSConstantStringImpl__var_folders_3q_sv9blc555sb1tfw4cl4wgl2h0000gn_T_main_b46ba9_mii_3,__func__);
}

//get方法
static NSString * _I_ZGTercher_zg_name(ZGTercher * self, SEL _cmd) { return (*(NSString **)((char *)self + OBJC_IVAR_$_ZGTercher$_zg_name)); }
extern "C" __declspec(dllimport) void objc_setProperty (id, SEL, long, id, bool, bool);
//set方法
static void _I_ZGTercher_setZg_name_(ZGTercher * self, SEL _cmd, NSString *zg_name) { objc_setProperty (self, _cmd, __OFFSETOFIVAR__(struct ZGTercher, _zg_name), (id)zg_name, 0, 1); }

查看 ZGTeacher类拓展的方法，在编译过程中，方法就直接添加到了 methodlist中，作为类的一部分，即编译时期直接添加到本类里面

static struct /*_ivar_list_t*/ {
    unsigned int entsize;  // sizeof(struct _prop_t)
    unsigned int count;
    struct _ivar_t ivar_list[2];
} _OBJC_$_INSTANCE_VARIABLES_ZGTercher __attribute__ ((used, section ("__DATA,__objc_const"))) = {
    sizeof(_ivar_t),
    2,
    {{(unsigned long int *)&OBJC_IVAR_$_ZGTercher$_zg_age, "_zg_age", "i", 2, 4},
     {(unsigned long int *)&OBJC_IVAR_$_ZGTercher$_zg_name, "_zg_name", "@\"NSString\"", 3, 8}}
};

static struct /*_method_list_t*/ {
    unsigned int entsize;  // sizeof(struct _objc_method)
    unsigned int method_count;
    struct _objc_method method_list[7];
} _OBJC_$_INSTANCE_METHODS_ZGTercher __attribute__ ((used, section ("__DATA,__objc_const"))) = {
    sizeof(_objc_method),
    7,
    {{(struct objc_selector *)"zg_instanceMethod3", "v16@0:8", (void *)_I_ZGTercher_zg_instanceMethod3},
    {(struct objc_selector *)"zg_instanceMethod1", "v16@0:8", (void *)_I_ZGTercher_zg_instanceMethod1},
    {(struct objc_selector *)"zg_instanceMethod2", "v16@0:8", (void *)_I_ZGTercher_zg_instanceMethod2},
    {(struct objc_selector *)"zg_name", "@16@0:8", (void *)_I_ZGTercher_zg_name},
    {(struct objc_selector *)"setZg_name:", "v24@0:8@16", (void *)_I_ZGTercher_setZg_name_},
    {(struct objc_selector *)"zg_age", "i16@0:8", (void *)_I_ZGTercher_zg_age},
    {(struct objc_selector *)"setZg_age:", "v20@0:8i16", (void *)_I_ZGTercher_setZg_age_}}
};

而我们在类中定义的方法也是直接加入到方法列表 _method_list_t中。这点可以说明，扩展是类的一部分，而且方法在编译期就加入到类中。

objc源码验证

新建一个ZGPerson+ZGExt的类扩展

@interface ZGPerson ()
@property (nonatomic, copy) NSString *ext_name;

- (void)ext_instanceMethod;

+ (void)ext_sayClassMethod;
@end

并且在ZGPerson中实现- (void)ext_instanceMethod;和 + (void)ext_sayClassMethod;方法

#import "ZGPerson.h"

@implementation ZGPerson

//+ (void)load{
//    
//}

- (void)kc_instanceMethod3{
    NSLog(@"%s",__func__);
}

- (void)kc_instanceMethod1{
    NSLog(@"%s",__func__);
}

- (void)kc_instanceMethod2{
    NSLog(@"%s",__func__);
}


+ (void)kc_sayClassMethod{
    NSLog(@"%s",__func__);
}

- (void)ext_instanceMethod{
    
}

+ (void)ext_sayClassMethod{
    
}

运行objc源码程序，在readClass中打个断点，然后我们去查看类的方法里列表中加载了哪些方法？

readClass

然后我们LLDB指令p kc_ro->baseMethodList读取baseMethodList内容，并读出其中p $0->get(0) ~ p $0->get(8)的数组元素内容

baseMethodList

当我们p $0->get(3)的时候就已经发现我们的类扩展方法，刚好验证了我们上面的结论。

总结

分类和类扩展如果是单独的文件都需要被导入。分类一般用来为类添加方法，类扩展可以用来减少不想对外暴露的属性、方法，但并不是真正的私有。

分类 VS 类扩展

分类关联对象原理探索

我们在分类中cate_name增加一个cate_name属性

@interface ZGPerson (ZGA)

@property (nonatomic, strong) NSString *cate_name;//分类属性
@property (nonatomic, assign) int cate_age;

- (void)cateA_instanceMethod1;

- (void)cateA_instanceMethod3;

- (void)cateA_instanceMethod2;

- (void)cateA_classMethod3;

@end

在main中对cate_name赋值

int main(int argc, const char * argv[]) {
    @autoreleasepool {

        // insert code here...
        ZGPerson *person = [ZGPerson alloc];
        person.cate_name = @"zg";
        [person kc_instanceMethod1];
    }
    return 0;
}

会报错


报错

但是当我们在分类中对属性进行关联对象处理

#import <objc/runtime.h>
static const void *cate_name_str = &cate_name_str;

@implementation ZGPerson (ZGA)

- (NSString *)cate_name {
    return objc_getAssociatedObject(self, cate_name_str);
}
- (void)setCate_name:(NSString *)cate_name{
     objc_setAssociatedObject(self, cate_name_str, cate_name, OBJC_ASSOCIATION_COPY_NONATOMIC);
}

运行后发现可以正常读取cate_name的值

其底层原理的实现，主要分为两部分：

  • 通过objc_setAssociatedObject设值流程
  • 通过objc_getAssociatedObject取值流程

其中objc_setAssociatedObject方法有四个参数，分别表示：

  • 参数1：要关联的对象，即给谁添加关联属性

  • 参数2：标识符，方便下次查找

  • 参数3：value

  • 参数4：属性的策略，即nonatomic、atomic、assign等，如下所示

    策略
objc_setAssociatedObject源码实现
void
objc_setAssociatedObject(id object, const void *key, id value, objc_AssociationPolicy policy)
{
    SetAssocHook.get()(object, key, value, policy);
}

此处与以往的objc开源代码不同，在781的这个版本的源码中，增加了一层代码封装，按住command点击SetAssocHook，能够看到这行代码：

static ChainedHookFunction<objc_hook_setAssociatedObject> SetAssocHook{_base_objc_setAssociatedObject};

进入_base_objc_setAssociatedObject源码实现：_base_objc_setAssociatedObject -> _object_set_associative_reference，通过断点调试，确实会来到这

_object_set_associative_reference 方法

进入_object_set_associative_reference源码实现，关于关联对象 底层原理的探索 主要是看value存到了哪里， 以及如何取出value ，以下是源码

void
_object_set_associative_reference(id object, const void *key, id value, uintptr_t policy)
{
    // This code used to work when nil was passed for object and key. Some code
    // probably relies on that to not crash. Check and handle it explicitly.
    // rdar://problem/44094390
    if (!object && !value) return;

    if (object->getIsa()->forbidsAssociatedObjects())
        _objc_fatal("objc_setAssociatedObject called on instance (%p) of class %s which does not allow associated objects", object, object_getClassName(object));
    //object封装成一个数组结构类型，类型为DisguisedPtr
    DisguisedPtr<objc_object> disguised{(objc_object *)object};//相当于包装了一下 对象object,便于使用
    // 包装一下 policy - value
    ObjcAssociation association{policy, value};

    // retain the new value (if any) outside the lock.
    association.acquireValue();//根据策略类型进行处理
    //局部作用域空间
    {
        //初始化manager变量，相当于自动调用AssociationsManager的析构函数进行初始化
        AssociationsManager manager;//并不是全场唯一，构造函数中加锁只是为了避免重复创建，在这里是可以初始化多个AssociationsManager变量的
    
        AssociationsHashMap &associations(manager.get());//AssociationsHashMap 全场唯一

        if (value) {
            //try_emplace，在这disguised作为key查找，如果已经在associations表中，就把查找到的桶作为DenseMapIterator的位置指针进行初始化，然后用pair包装后返回；key没在associations表中就把disguised作为key，ObjectAssociationMap{}作为value存入桶中，然后把该桶作为DenseMapIterator的位置指针进行初始化，然后用pair包装后返回。返回值类型std::pair<DenseMapIterator, bool>
            auto refs_result = associations.try_emplace(disguised, ObjectAssociationMap{});
            if (refs_result.second) {//判断第二个存不存在，即bool值是否为true
                /* it's the first association we make 第一次建立关联*/
                object->setHasAssociatedObjects();//nonpointerIsa ，标记位true
            }

            /* establish or replace the association 建立或者替换关联*/
            auto &refs = refs_result.first->second; //得到一个空的桶子，找到引用对象类型,即第一个元素的second值
            auto result = refs.try_emplace(key, std::move(association));//查找当前的key是否有association关联对象
            if (!result.second) {//如果结果不存在
                association.swap(result.first->second);
            }
        } else {   //value为nil, 取消关联。看懂了上面这里就很简单了。
            //先从associations表中找到disguised对应的ObjectAssociationMap表，又用pair包装后返回。
            auto refs_it = associations.find(disguised);
            //如果从associations表中找到了disguised对应的ObjectAssociationMap表，就走进去
            if (refs_it != associations.end()) {
                //从pair中拿到ObjectAssociationMap表
                auto &refs = refs_it->second;
                //从ObjectAssociationMap表中查找key对应的association，然后把它作为DenseMapIterator的位置指针初始化后返回
                auto it = refs.find(key);
                //如果找到了就进去
                if (it != refs.end()) {
                    //这里交换值是为了把要擦除的association记录下来，因为下面还要进行releaseHeldValue
                    association.swap(it->second);
                    //从ObjectAssociationMap表中擦除association以及其他相应的操作
                    refs.erase(it);
                    if (refs.size() == 0) {
                        //说明没有关联的值了，从associations表中擦除ObjectAssociationMap表
                        associations.erase(refs_it);
                    }
                }
            }
        }
    }

    // release the old value (outside of the lock).
    association.releaseHeldValue();
}

其中流程如下

  • 1: 创建一个 AssociationsManager 管理类
  • 2: 获取唯一的全局静态哈希Map
  • 3: 判断是否插入的关联值是否存在:
    • 3.1: 存在走第4步
    • 3.2: 不存在就走 : 关联对象插入空流程
  • 4: 创建一个空的 ObjectAssociationMap去取查询的键值对
  • 5: 如果发现没有这个key就插入一个 空的BucketT进去返回
  • 6: 标记对象存在关联对象
  • 7: 用当前 修饰策略和 值组成了一个ObjcAssociation 替换原来 BucketT中的空
  • 8: 标记一下ObjectAssociationMap 的第一次为 false

关联对象插入空流程

  • 1: 根据DisguisedPtr 找到 AssociationsHashMap 中的iterator迭代查询器
  • 2: 清理迭代器
  • 3: 其实如果插入空置 相当于清除

其中try_emplace的源码如下

// Inserts key,value pair into the map if the key isn't already in the map.
  // The value is constructed in-place if the key is not in the map, otherwise
  // it is not moved.
  template <typename... Ts>
  std::pair<iterator, bool> try_emplace(const KeyT &Key, Ts &&... Args) {
    BucketT *TheBucket;
    if (LookupBucketFor(Key, TheBucket))
      return std::make_pair(
               makeIterator(TheBucket, getBucketsEnd(), true),
               false); // Already in map.

    // Otherwise, insert the new element.
    TheBucket = InsertIntoBucket(TheBucket, Key, std::forward<Ts>(Args)...);
    return std::make_pair(
             makeIterator(TheBucket, getBucketsEnd(), true),
             true);
  }

有两个返回，都是通过std::make_pair生成相应的键值对
通过LookupBucketFor方法查找桶子，如果map中已经存在，则直接返回，其中make_pair的第二个参数bool值为false
如果没有找到，则通过InsertIntoBucket插入map，其中make_pair的第二个参数bool值为true

下面通过LLDB断点打印来帮助理解源码中的内容，可以看到设置的值zg

设置的值

接下来打印最初的association和associations

(lldb) p association
(objc::ObjcAssociation) $0 = {
  _policy = 3
  _value = 0x0000000100002038 "zg"
}
(lldb) p associations
(objc::AssociationsHashMap) $1 = {
  Buckets = 0x0000000000000000
  NumEntries = 0
  NumTombstones = 0
  NumBuckets = 0
}

接着打印了refs_result的一些内容，下面会省略一些类型的参数来方便查看

(lldb) p refs_result
(std::__1::pair<objc::DenseMapIterator<DisguisedPtr<objc_object>, objc::DenseMap<const void *, objc::ObjcAssociation, objc::DenseMapValueInfo<objc::ObjcAssociation>, objc::DenseMapInfo<const void *>, objc::detail::DenseMapPair<const void *, objc::ObjcAssociation> >, objc::DenseMapValueInfo<objc::DenseMap<const void *, objc::ObjcAssociation, objc::DenseMapValueInfo<objc::ObjcAssociation>, objc::DenseMapInfo<const void *>, objc::detail::DenseMapPair<const void *, objc::ObjcAssociation> > >, objc::DenseMapInfo<DisguisedPtr<objc_object> >, objc::detail::DenseMapPair<DisguisedPtr<objc_object>, objc::DenseMap<const void *, objc::ObjcAssociation, objc::DenseMapValueInfo<objc::ObjcAssociation>, objc::DenseMapInfo<const void *>, objc::detail::DenseMapPair<const void *, objc::ObjcAssociation> > >, false>, bool>) $1 = {
  first = {
    Ptr = 0x0000000101027410
    End = 0x0000000101027490
  }
  second = true
}
(lldb)  p *refs_result.first
(objc::DenseMapIterator<DisguisedPtr<objc_object>, objc::DenseMap<const void *, objc::ObjcAssociation, objc::DenseMapValueInfo<objc::ObjcAssociation>, objc::DenseMapInfo<const void *>, objc::detail::DenseMapPair<const void *, objc::ObjcAssociation> >, objc::DenseMapValueInfo<objc::DenseMap<const void *, objc::ObjcAssociation, objc::DenseMapValueInfo<objc::ObjcAssociation>, objc::DenseMapInfo<const void *>, objc::detail::DenseMapPair<const void *, objc::ObjcAssociation> > >, objc::DenseMapInfo<DisguisedPtr<objc_object> >, objc::detail::DenseMapPair<DisguisedPtr<objc_object>, objc::DenseMap<const void *, objc::ObjcAssociation, objc::DenseMapValueInfo<objc::ObjcAssociation>, objc::DenseMapInfo<const void *>, objc::detail::DenseMapPair<const void *, objc::ObjcAssociation> > >, false>::value_type) $2 = {
  std::__1::pair<DisguisedPtr<objc_object>, objc::DenseMap<const void *, objc::ObjcAssociation, objc::DenseMapValueInfo<objc::ObjcAssociation>, objc::DenseMapInfo<const void *>, objc::detail::DenseMapPair<const void *, objc::ObjcAssociation> > > = {
    first = (value = 18446744069407759344)
    second = {
      Buckets = 0x0000000100683030
      NumEntries = 1
      NumTombstones = 0
      NumBuckets = 4
    }
  }
}
(lldb) p refs_result.first->second
(objc::DenseMap<const void *, objc::ObjcAssociation, objc::DenseMapValueInfo<objc::ObjcAssociation>, objc::DenseMapInfo<const void *>, objc::detail::DenseMapPair<const void *, objc::ObjcAssociation> >) $3 = {
  Buckets = 0x0000000100683030
  NumEntries = 1
  NumTombstones = 0
  NumBuckets = 4
}
(lldb)  p result
(std::__1::pair<objc::DenseMapIterator<const void *, objc::ObjcAssociation, objc::DenseMapValueInfo<objc::ObjcAssociation>, objc::DenseMapInfo<const void *>, objc::detail::DenseMapPair<const void *, objc::ObjcAssociation>, false>, bool>) $4 = {
  first = {
    Ptr = 0x0000000100683078
    End = 0x0000000100683090
  }
  second = true
}
(lldb)

最后再打印一下association和associations

(lldb) p association
(objc::ObjcAssociation) $5 = {
  _policy = 0
  _value = nil
}
(lldb) p associations
(objc::AssociationsHashMap) $6 = {
  Buckets = 0x0000000101027410
  NumEntries = 1
  NumTombstones = 0
  NumBuckets = 4
}
(lldb)

所以到目前为止，关联属性涉及的map结构如下

哈希map结构

AssociationsHashMap表是以伪装后的objc_object指针为key，ObjectAssociationMap是以const void *类型的指针为key。

objc_getAssociatedObject源码分析
id objc_getAssociatedObject(id object, const void *key)
{
    return _object_get_associative_reference(object, key);
}

id _object_get_associative_reference(id object, const void *key)
{   
    //先初始化一个用来接收值的association
    ObjcAssociation association{};
    {
        AssociationsManager manager;
        AssociationsHashMap &associations(manager.get());
        //用object作为key从associations表中找到对应的ObjectAssociationMap表
        AssociationsHashMap::iterator i = associations.find((objc_object *)object);
        if (i != associations.end()) {
            ObjectAssociationMap &refs = i->second;
            //用key在ObjectAssociationMap表中搜索对应的ObjcAssociation
            ObjectAssociationMap::iterator j = refs.find(key);
            if (j != refs.end()) {
                //找到后赋值给association，然后retain
                association = j->second;
                association.retainReturnedValue();
            }
        }
    }

    return association.autoreleaseReturnedValue();
}
  • 1：创建一个AssociationsManager管理类
  • 2：获取唯一的全局静态哈希Map：AssociationsHashMap
  • 3：通过find方法根据DisguisedPtr 找到AssociationsHashMap 中的 iterator迭代查询器
  • 4：如果这个迭代查询器不是最后一个 获取 : ObjectAssociationMap (policy和value)
  • 5：通过find方法找到ObjectAssociationMap的迭代查询器获取一个经过属性修饰符修饰的value
  • 6：返回value
关联对象释放

在对象调用dealloc方法释放时，通过_objc_rootDealloc->rootDealloc->object_dispose->objc_destructInstance

void *objc_destructInstance(id obj) 
{
    if (obj) {
        // Read all of the flags at once for performance.
        bool cxx = obj->hasCxxDtor();
        bool assoc = obj->hasAssociatedObjects();

        // This order is important.
        if (cxx) object_cxxDestruct(obj);
        //如果有关联对象，移除
        if (assoc) _object_remove_assocations(obj);
        obj->clearDeallocating();
    }
    return obj;
}

void _object_remove_assocations(id object)
{
    ObjectAssociationMap refs{};
    {
        AssociationsManager manager;
        AssociationsHashMap &associations(manager.get());
        AssociationsHashMap::iterator i = associations.find((objc_object *)object);
        if (i != associations.end()) {
            refs.swap(i->second);
            associations.erase(i);
        }
    }
    // release everything (outside of the lock).
    for (auto &i: refs) {
        i.second.releaseHeldValue();
    }
}

从中可以看出关联对象不用手动移除，在对象释放时会自动移除。

总结

所以，综上所述，所以关联对象的底层调用流程如下图所示

关联对象的底层调用流程

总的来说，关联对象主要就是两层哈希map的处理，即存取时都是两层处理，类似于二维数组

最后编辑于 ：
©著作权归作者所有,转载或内容合作请联系作者
  • 人面猴
    序言：七十年代末，一起剥皮案震惊了整个滨河市，随后出现的几起案子，更是在滨河造成了极大的恐慌，老刑警刘岩，带你破解...
    沈念sama阅读 205,236评论 6赞 478
  • 死咒
    序言：滨河连续发生了三起死亡事件，死亡现场离奇诡异，居然都是意外死亡，警方通过查阅死者的电脑和手机，发现死者居然都...
    沈念sama阅读 87,867评论 2赞 381
  • 救了他两次的神仙让他今天三更去死
    文/潘晓璐 我一进店门，熙熙楼的掌柜王于贵愁眉苦脸地迎上来，“玉大人，你说我怎么就摊上这事。” “怎么了？”我有些...
    开封第一讲书人阅读 151,715评论 0赞 340
  • 道士缉凶录：失踪的卖姜人
    文/不坏的土叔 我叫张陵，是天一观的道长。 经常有香客问我，道长，这世上最难降的妖魔是什么？ 我笑而不...
    开封第一讲书人阅读 54,899评论 1赞 278
  • 港岛之恋（遗憾婚礼）
    正文 为了忘掉前任，我火速办了婚礼，结果婚礼上，老公的妹妹穿的比我还像新娘。我一直安慰自己，他们只是感情好，可当我...
    茶点故事阅读 63,895评论 5赞 368
  • 恶毒庶女顶嫁案：这布局不是一般人想出来的
    文/花漫 我一把揭开白布。 她就那样静静地躺着，像睡着了一般。 火红的嫁衣衬着肌肤如雪。 梳的纹丝不乱的头发上，一...
    开封第一讲书人阅读 48,733评论 1赞 283
  • 城市分裂传说
    那天，我揣着相机与录音，去河边找鬼。 笑死，一个胖子当着我的面吹牛，可吹牛的内容都是我干的。 我是一名探鬼主播，决...
    沈念sama阅读 38,085评论 3赞 399
  • 双鸳鸯连环套：你想象不到人心有多黑
    文/苍兰香墨 我猛地睁开眼，长吁一口气：“原来是场噩梦啊……” “哼！你这毒妇竟也来了？” 一声冷哼从身侧响起，我...
    开封第一讲书人阅读 36,722评论 0赞 258
  • 万荣杀人案实录
    序言：老挝万荣一对情侣失踪，失踪者是张志新（化名）和其女友刘颖，没想到半个月后，有当地人在树林里发现了一具尸体，经...
    沈念sama阅读 43,025评论 1赞 300
  • 护林员之死
    正文 独居荒郊野岭守林人离奇死亡，尸身上长有42处带血的脓包…… 初始之章·张勋 以下内容为张勋视角 年9月15日...
    茶点故事阅读 35,696评论 2赞 323
  • 白月光启示录
    正文 我和宋清朗相恋三年，在试婚纱的时候发现自己被绿了。 大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
    茶点故事阅读 37,816评论 1赞 333
  • 活死人
    序言：一个原本活蹦乱跳的男人离奇死亡，死状恐怖，灵堂内的尸体忽然破棺而出，到底是诈尸还是另有隐情，我是刑警宁泽，带...
    沈念sama阅读 33,447评论 4赞 322
  • 日本核电站爆炸内幕
    正文 年R本政府宣布，位于F岛的核电站，受9级特大地震影响，放射性物质发生泄漏。R本人自食恶果不足惜，却给世界环境...
    茶点故事阅读 39,057评论 3赞 307
  • 男人毒药：我在死后第九天来索命
    文/蒙蒙 一、第九天 我趴在偏房一处隐蔽的房顶上张望。 院中可真热闹，春花似锦、人声如沸。这庄子的主人今日做“春日...
    开封第一讲书人阅读 30,009评论 0赞 19
  • 一桩弑父案，背后竟有这般阴谋
    文/苍兰香墨 我抬头看了看天上的太阳。三九已至，却和暖如春，着一层夹袄步出监牢的瞬间，已是汗流浃背。 一阵脚步声响...
    开封第一讲书人阅读 31,254评论 1赞 260
  • 情欲美人皮
    我被黑心中介骗来泰国打工， 没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留，地道东北人。 一个月前我还...
    沈念sama阅读 45,204评论 2赞 352
  • 代替公主和亲
    正文 我出身青楼，却偏偏与公主长得像，于是被迫代替她去往敌国和亲。 传闻我的和亲对象是个残疾皇子，可洞房花烛夜当晚...
    茶点故事阅读 42,561评论 2赞 343