COW和SSO

最新推荐文章于 2021-12-27 23:28:16 发布
最新推荐文章于 2021-12-27 23:28:16 发布
阅读量465 收藏
点赞数 2
分类专栏： C++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43003442/article/details/114341390
版权

GCC 4.x.x string的实现是 COW (写时复制)
GCC 5.x.x string的实现是 SSO (短字符串优先)

验证COW的存在

在g++ 4.

	std::string s1 = "hello,world";
	std::string s2(s1);
	printf("s1'addr = %p, str = %s, s2'addr = %p,str = %s\n", s1.c_str(), s1.c_str(), s2.c_str(), s2.c_str());

	s2[0] = 'H';
	printf("s1'addr = %p, str = %s, s2'addr = %p,str = %s\n", s1.c_str(), s1.c_str(), s2.c_str(), s2.c_str());

该例子可以看到，s2复制s1的时候进行的是浅拷贝，两者指向同一块空间，当s2发生修改时，s2会重新申请空间。

验证SSO的存在

在g++ 5.4.0

	std::string s1 = "hello,world";

	printf("s1'size = %d\n", sizeof(s1)); // 可以看到string不再是一个指针

	std::string s3 = "1234567891111111"; // 可以看到超过15个字符s3就在堆上了
	printf("s1'size = %p\n", s3.c_str());


	std::string s2(s1);
	printf("s1'addr = %p, str = %s, s2'addr = %p,str = %s\n", s1.c_str(), s1.c_str(), s2.c_str(), s2.c_str());

	std::string s4(s3); // 可以看到SSO没用引用计数，每次都是重新申请空间
	printf("s3'addr = %p, str = %s, s4'addr = %p,str = %s\n", s3.c_str(), s3.c_str(), s4.c_str(), s4.c_str());

如果想让SSO提升，在大于15字符后采用引用计数，可以看看FaceBook开源库中string的实现 https://github.com/facebook/folly.git

一个简单的写时复制实现

该图来自《Effective STL》条款15
实现思路:
上图来自《Effective STL》条款15，本例只实现RefCnt和Value，Size Capactity暂时不管。
①class COWString中定义一个char的成员，char的前四个字节存放引用计数，后面存放实际的字符串。
②当发生复制构造和赋值操作时，执行浅拷贝，引用计数加1，有对象析构时引用计数减1，只有当引用计数为0时才释放空间
③当对象发生修改时，重载operator[]，进行深拷贝

#include <iostream>
#include <stdio.h>

class COWString {
public:
	COWString();
	COWString(const char* pstr);
	COWString(const COWString& rhs);
	COWString& operator=(const COWString& rhs);
	~COWString();

	const char& operator[](size_t idx) const { return _pstr[idx]; }
	char& operator[](size_t idx);


	size_t size() { return strlen(_pstr); }
	const char* c_str() const { return _pstr; }

	size_t refcount() const { return *(int*)(_pstr - 4); }

private:
	void initRefcount() { *(int*)_pstr = 1; }
	void increaseRefcount() { (*(int*)(_pstr - 4))++; }
	void decreaseRefcount()
	{ 
		if (_pstr == NULL) {
			return;
		}
		(*(int*)(_pstr - 4))--; 
	}
	void release()
	{
		decreaseRefcount();
		if (refcount() == 0) {
			std::cout << "delete _pstr" << std::endl;
			delete [](_pstr - 4);   // 注意这里一定要减4,不然内存泄露
		}
	}
private:
	char* _pstr;
};

COWString::COWString()
{
	this->_pstr = new char[5]();  // 前四个字节用来存放引用计数，再加上一个'\0'，申请5个字节  注意这里的()要加上，不然申请的数组没有初始化，可能会有脏数据 重载了operator+后几个字符串相加会触发这个bug
	initRefcount();
	this->_pstr += 4;
}

COWString::COWString(const char* pstr)
{
	this->_pstr = new char[strlen(pstr) + 5]();
	initRefcount();
	this->_pstr += 4;
	strcpy_s(this->_pstr, strlen(pstr) + 1, pstr);
}

COWString::COWString(const COWString& rhs)
{
	this->_pstr = rhs._pstr;
	increaseRefcount();
}

COWString& COWString::operator=(const COWString& rhs)
{
	if (this != &rhs) {
		release();
		this->_pstr = rhs._pstr;
		increaseRefcount();
	}
	return *this;
}

// 下标访问运算符无法区分出是读操作还是写操作
char& COWString::operator[](size_t idx)
{
	if (refcount() > 1) {
		char* tmp = new char[strlen(_pstr) + 5]();
		tmp += 4;
		strcpy_s(tmp, size() + 1, this->_pstr);
		decreaseRefcount();
		this->_pstr = tmp;
		increaseRefcount();
	}
	return _pstr[idx];
}

COWString::~COWString()
{
	std::cout << "COWString::~COWString " << _pstr << std::endl;
	release();
}

int main()
{
	COWString s1("hello");
	COWString s2(s1);
	COWString s3 = s1;

	printf("s1' addr = %p, s1' c_str() = %s, refcount = %d\n", s1.c_str(), s1.c_str(), (int)s1.refcount());
	printf("s2' addr = %p, s2' c_str() = %s, refcount = %d\n", s2.c_str(), s2.c_str(), (int)s2.refcount());
	printf("s3' addr = %p, s3' c_str() = %s, refcount = %d\n", s3.c_str(), s3.c_str(), (int)s3.refcount());

	std::cout << "执行修改操作后" << std::endl;
	s3[1] = 'E';
	printf("s1' addr = %p, s1' c_str() = %s, refcount = %d\n", s1.c_str(), s1.c_str(), (int)s1.refcount());
	printf("s2' addr = %p, s2' c_str() = %s, refcount = %d\n", s2.c_str(), s2.c_str(), (int)s2.refcount());
	printf("s3' addr = %p, s3' c_str() = %s, refcount = %d\n", s3.c_str(), s3.c_str(), (int)s3.refcount());
	
	return 0;
}

执行结果如图：
在这里插入图片描述
思考：
引用计数为什么要与char*放一起，不能单独定义一个成员变量存储？
①引用计数作为成员变量如：

class COWString{
	char* _pstr;
	int _refCnt;
}

这样不行，每个对象的引用计数相互独立了，无法同步增减。
②引用计数作为静态成员变量如：

class COWString{
	char* _pstr;
	static int _refCnt;
}

这样不行，静态成员变量为整个类共有，会造成不是指向同一个字符串的对象的引用计数也一致了。
③通过保存引用计数的指针：

class COWString{
	char* _pstr;
	int* _refCnt;
}

这样可行，不过要申请两次内存，因此将两个成员合并就是本例的实现。
④通过对象成员：

class String{
    friend class COWString;
	char* _pstr;
	int _refCnt;
}
class COWString{
	String* _string;;
}

可行。

区分读写操作的写时复制实现

上面的例子有个问题，就是只访问下标的元素，没有发生修改时，也会去重新开辟空间，如：const char c = s1[0];
实现思路：
①写操作：s1[0] = ‘H’; 先调用COWString::operator[idx]返回char，然后调用char的operator=修改变量
读操作：const char c = s1[0]; 仅仅调用COWString::operator[idx]返回char
因此区分读还是写操作就在于是否调用了char类型对象的operator=对operator[idx]重新赋值，COWString::operator[idx]返回的是一个char，由于char是内置类型，不能重载，因此我们考虑将COWString::operator[idx]返回一个自定义对象，然后重载自定义对象的operator=，这样写操作就实现了
②由于COWString::operator[idx]返回一个自定义对象，例const char c = s1[0]返回的自定义对象不能直接赋值给char类型变量，因此需要类型转换函数来解决。

#include <iostream>
#include <stdio.h>

class COWString {
	class CharProxy {
	public:
		CharProxy(size_t idx, COWString& self)
		: _idx(idx), _self(self)
		{}

		operator char() { // 类型转换函数
			std::cout << "CharProxy::operator char()" << std::endl;
			return _self._pstr[_idx];
		}
		char& operator=(const char& ch)
		{
			if (_self.refcount() > 1) {
				char* tmp = new char[strlen(_self._pstr) + 5]();
				tmp += 4;
				strcpy_s(tmp, _self.size() + 1, _self._pstr);
				_self.decreaseRefcount();
				_self._pstr = tmp;
				_self.increaseRefcount();
			}
			return _self._pstr[_idx];
		}
	private:
		size_t _idx;
		COWString& _self;
	};
public:
	COWString();
	COWString(const char* pstr);
	COWString(const COWString& rhs);
	COWString& operator=(const COWString& rhs);
	~COWString();

	const char& operator[](size_t idx) const
	{ 
		return _pstr[idx]; 
	}
	CharProxy operator[](size_t idx);


	size_t size() { return strlen(_pstr); }
	const char* c_str() const { return _pstr; }

	size_t refcount() const { return *(int*)(_pstr - 4); }

private:
	void initRefcount() { *(int*)_pstr = 1; }
	void increaseRefcount() { (*(int*)(_pstr - 4))++; }
	void decreaseRefcount()
	{ 
		if (_pstr == NULL) {
			return;
		}
		(*(int*)(_pstr - 4))--; 
	}
	void release()
	{
		decreaseRefcount();
		if (refcount() == 0) {
			std::cout << "delete _pstr" << std::endl;
			delete [](_pstr - 4);   // 注意这里一定要减4,不然内存泄露
		}
	}
private:
	char* _pstr;
};

COWString::COWString()
{
	this->_pstr = new char[5]();  // 前四个字节用来存放引用计数，再加上一个'\0'，申请5个字节  注意这里的()要加上，不然申请的数组没有初始化，可能会有脏数据 重载了operator+后几个字符串相加会触发这个bug
	initRefcount();
	this->_pstr += 4;
}

COWString::COWString(const char* pstr)
{
	this->_pstr = new char[strlen(pstr) + 5]();
	initRefcount();
	this->_pstr += 4;
	strcpy_s(this->_pstr, strlen(pstr) + 1, pstr);
}

COWString::COWString(const COWString& rhs)
{
	this->_pstr = rhs._pstr;
	increaseRefcount();
}

COWString& COWString::operator=(const COWString& rhs)
{
	if (this != &rhs) {
		release();
		this->_pstr = rhs._pstr;
		increaseRefcount();
	}
	return *this;
}

// 注意这里是返回的对象，return的是个临时对象，返回引用，临时对象销毁，会异常
COWString::CharProxy COWString::operator[](size_t idx)
{
	return CharProxy(idx, *this);
}

COWString::~COWString()
{
	std::cout << "COWString::~COWString " << _pstr << std::endl;
	release();
}

int main()
{
	COWString s1("hello");
	COWString s2(s1);
	COWString s3 = s1;

	printf("s1' addr = %p, s1' c_str() = %s, refcount = %d\n", s1.c_str(), s1.c_str(), (int)s1.refcount());
	printf("s2' addr = %p, s2' c_str() = %s, refcount = %d\n", s2.c_str(), s2.c_str(), (int)s2.refcount());
	printf("s3' addr = %p, s3' c_str() = %s, refcount = %d\n", s3.c_str(), s3.c_str(), (int)s3.refcount());

	std::cout << "执行写操作后 s3[1] = 'E' " << std::endl;
	s3[1] = 'E';
	printf("s1' addr = %p, s1' c_str() = %s, refcount = %d\n", s1.c_str(), s1.c_str(), (int)s1.refcount());
	printf("s2' addr = %p, s2' c_str() = %s, refcount = %d\n", s2.c_str(), s2.c_str(), (int)s2.refcount());
	printf("s3' addr = %p, s3' c_str() = %s, refcount = %d\n", s3.c_str(), s3.c_str(), (int)s3.refcount());

	std::cout << "执行读操作后 s2[1] " << s2[1] << std::endl;
	s3[1] = 'E';
	printf("s1' addr = %p, s1' c_str() = %s, refcount = %d\n", s1.c_str(), s1.c_str(), (int)s1.refcount());
	printf("s2' addr = %p, s2' c_str() = %s, refcount = %d\n", s2.c_str(), s2.c_str(), (int)s2.refcount());
	printf("s3' addr = %p, s3' c_str() = %s, refcount = %d\n", s3.c_str(), s3.c_str(), (int)s3.refcount());

	const char c = s2[1]; // 隐式调用类型转换成员函数
	std::cout << "执行读操作后 s2[1] " << c << std::endl;
	printf("s1' addr = %p, s1' c_str() = %s, refcount = %d\n", s1.c_str(), s1.c_str(), (int)s1.refcount());
	printf("s2' addr = %p, s2' c_str() = %s, refcount = %d\n", s2.c_str(), s2.c_str(), (int)s2.refcount());
	printf("s3' addr = %p, s3' c_str() = %s, refcount = %d\n", s3.c_str(), s3.c_str(), (int)s3.refcount());
	
	return 0;
}

执行结果如图：
在这里插入图片描述

参考资料：https://www.cnblogs.com/cthon/p/9181979.html
http://www.kohn.com.cn/wordpress/?p=245
《Effective STL》

feiyang0205
关注
  • 2
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
COW(copy on write)， SSO (small string optimization)浅析
imJaron的博客
11-20 1313
有如下一段代码， 则输出结果是？ 不一样的编译器可能会有不一样的结果，原因在于所使用的引用计数方法是COW还是SSO。比如VS上结果是false, false, false, 而老版本GCC上则是true, true, false，因trs为STL标准库对string的实现方法不同。 首先要明确一点，目前的实现中，不管哪种方式string的拷贝是深拷贝的。但是如果每次都
C++ string的COW和SSO策略
小小的进步
03-14 1932
现代化的编译器大多数都是实现的SSO策略，我们在编码过程中不用太关注string的实现细节，但对于COW和SSO的基本概念要有基础的了解，更进一步的了解COW和SSO策略可以查看对应编译器提供的源码。
C++ string的COW和SSO
kemaWCZ的博客
09-30 4315
还记得书本上的关于深拷贝和浅拷贝的问题吗？ 如果自己写的一个类TestClass，采用的是默认的构造函数，或者采用自定义的构造函数（但是没有实现深拷贝）。那么下面的代码： class TestClass { public: char * p; }; TestClass a; TestClass  b(a); TestClass  c = a; 上诉都是浅
自己实现 写时复制（cow）模式 的c++ string类型 使用了设计模式之代理模式
带着你的名字的博客
05-19 1097
实现COW（写时复制）模式的String，让其operator[]能够区分出读写操作，从而避免只读时也修改引用计数。 使用了设计模式中的 代理模式 来实现下标运算符和赋值运算符的重载，从而完整的实现COW（写时复制）。 代码实现如下： my_string.h #ifndef __MY_STRING_H__ #define __MY_STRING_H__ #include <string.h> #include <iostream> using namespace std; cl
C++ string 类 部分成员函数实现（实现COW copy-on-write）
A Light Clean Place
05-02 1178
虽然标题中说实现了·COW，但是事实上是很浪费的，并且命名也很不标准，代码也非常小学生，毕竟初学（给自己找借口.jpg），以后应该还会把这篇找出来认真修改一下的。 Mystring.h： #pragma once #ifndef _MYSTRING_H_ #define _MYSTRING_H_ #include #include using namespace std; class My
完全跨域SSO
01-12
一种方法是使用一个共享的父域名，如`.company.com`，这样所有的子域名如`app1.company.com`和`app2.company.com`都能访问到同一个cookie。 6. **安全考虑**：SSO涉及到敏感的用户信息，因此必须确保通信的加密和...
asp.net SSO单点登录例子
12-22
目标是创建一个统一的登录系统sso.a.com，用户只需在此系统中登录一次，就能无缝地在app1.a.com和app2.a.com之间切换，无需重复登录。 实现ASP.NET SSO的关键知识点包括： 1. **身份验证模型**：SSO的核心是统一的...
phpcms 的sso通信失败的解决和思路
09-29
标题中的"phpcms 的sso通信失败的解决和思路"涉及到的是PHP CMS系统phpcms在实现单点登录（Single Sign-On, SSO）时遇到的问题及其...在部署和配置SSO系统时，需要考虑到服务器的网络环境和DNS设置，确保通信的顺畅性。
PHP中SSO Cookie登录分析和实现
12-18
在PHP中实现SSO，通常涉及Cookie和重定向技术。由于Cookie的域限制，不同域名下的系统无法直接共享Cookie，这就需要用到Ticket验证机制。以下是使用Ticket实现SSO的基本步骤： 1. 用户访问子系统，如果未登录，会被...
koa2-sso:也是cas中间件
05-08
Koa CAS认证 这是设计用于Koa服务器的CAS身份验证库。 它提供了两个中间件功能来控制对路由的访问： bounce ：将未经身份验证的客户端重定向到CAS登录... cas_url : 'https://my-cas-host.com/cas' , service_url :
c++基础自己实现一个String类（COW）
FairLikeSnow的博客
09-15 536
写时拷贝（Copy On Write） 使用了引用计数，在开辟空间时会多开辟4个字节用来保存引用计数的值。当第一个对象构造时，String的构造函数会根据传入的参数从堆上分配内存，当有其他对象需要这块内存时，计数器++，当有对象进行析构释放时，引用计数–，直到最会一个对象被析构，此时计数器为0。只有这样程序才会真正的释放掉这块从堆上分配的内存。 #include <iostream> #include <Windows.h> #pragma warning (disable:4996
C++学习之第十三天-移动语义与完成COW String类
weixin_49278191的博客
11-12 956
1.如何区分左值、右值、左值引用、右值引用、const左值引用。 String(const char *); String(const String &); ~String(); 问题：临时对象的构造和析构带来了不必要的资源拷贝 解决：右值机制-可以在语法层面识别出临时对象，在使用临时对象构造新对象时(即拷贝构造)，将临时对象的所有资源都转移到新的对象中，能消除这种不必要的拷贝。 左值和右值： 1.能对表达式进行取地址的为左值，否则为右值；左值和右值都针对表达式而言的。 2.左值是指表达式结束
c++实现string的写时复制技术（COW）——注释超细版
weixin_48617416的博客
12-27 3809
c++实现string的写时复制技术（COW）——注释超细版 COW（copy-on-write） 前言 当字符串进行复制的时候，如很长的字符串（2k大小），如果全部采用堆空间存储的话那是非常浪费空间的，复制一次变成4k大小，两次6k… 所以为了节约空间，在两个字符串都是相同内容的时候，将复制后的指针指向原始字符串的地址空间，然后采用引用计数的方式对该空间的引用数+1；当修改某一指针的内容时，其实就是改变了字符串数据，那么显然变成了一个新的字符串，这时候就需要给这个新的字符串重新申请一块堆空间了，然后对原始
String系列——写时复制COW
奔跑的小河
07-31 872
实现写时复制技术，这其中包含了引用技术原理。
C++学习之第九天-自动释放单例模式
weixin_49278191的博客
11-04 1480
编程题 1、实现单例模式的自动释放（4种方式） 1.1友元类实现单例模式的释放。 知识点： 要实现自动释放，可以考虑用一个栈对象，一个类在栈上创建一个对象，在程序执行结束后，栈对象空间被自动释放，会去调用该类的析构函数。把释放单例模式指针的代码放在该类中就可以实现自动释放。 #include <iostream> using namespace std; class AutoRelease;//1.要在单例模式中作为友元，所以先进行声明 class Singlet...
string类的写时复制COW技术（copy on write）
Worthy_Wang的博客
03-09 502
string类的写时复制COW技术（copy on write） 文章目录string类的写时复制COW技术（copy on write）@[toc]一.COW写时复制技术二.引用计数(RefCount)实现三.String类实现(无代理模式Proxy版)四.String类实现(代理模式Proxy版) 一.COW写时复制技术 string s1("s1"); string s2(s1); str...
string之eager-copy、COW和SSO方案
weixin_30298497的博客
07-27 191
https://www.cnblogs.com/cthon/p/9181979.html folly库的string实现： 　　三种方式结合使用：http://developer.51cto.com/art/201206/340617.htm 转载于:https://www.cnblogs.com/vinke2013/p/9683016.html...
Cow.h[运算符重载][C++,类]
qq_44699909的博客
02-08 216
#pragma once #include #include using namespace std; class pork; class Goat; class Cow //牛类 { public: Cow(int weight = 0); //使用运算符重载来实现变态加法 //使用operator运算符重载有一个默认参数是对象本身如自己(Cow) pork operator+(const ...
sso client配置
最新发布
07-13
- `sso.client.id`和`sso.client.secret`：客户端的应用ID和应用密钥，用于与服务端进行身份验证。 - `sso.client.callback.url`：客户端的回调URL，用于接收认证结果。一般是客户端应用中的一个特定接口或页面，...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值