├── CMakeLists.txt
├── KString.cpp
├── KString.h
├── KUnicodeString.cpp
├── KUnicodeString.h
├── KVector.cpp
├── KVector.h
├── SharedPointer.h
└── main.cpp


/CMakeLists.txt:
--------------------------------------------------------------------------------
 1 | cmake_minimum_required(VERSION 2.8)
 2 | project(string_test)
 3 | set(CMAKE_BUILD_TYPE debug)
 4 | set(sources main.cpp
 5 | 	KString.cpp
 6 | 	KVector.cpp
 7 | 	KUnicodeString.cpp)
 8 | set(headers KString.h
 9 | 	KVector.h
10 | 	KUnicodeString.h)
11 | add_executable(${PROJECT_NAME} ${headers} ${sources})
12 | 


--------------------------------------------------------------------------------
/KString.cpp:
--------------------------------------------------------------------------------
  1 | #include "KString.h"
  2 | #include <string.h>
  3 | 
  4 | 
  5 | KString::KString()
  6 | 	: s_(0)
  7 | 	, size_(0)
  8 | {
  9 | 
 10 | }
 11 | 
 12 | 
 13 | 
 14 | static wchar_t* copy_string(const char* s)
 15 | {
 16 | 	size_t length = strlen(s);
 17 | 	wchar_t* ws = new wchar_t[length + 1];
 18 | 	ws[length] = 0;
 19 | 	for(size_t i = 0; i < length; ++i)
 20 | 		ws[i] = s[i];
 21 | 	return ws;
 22 | }
 23 | 
 24 | static wchar_t* copy_string(const wchar_t* s)
 25 | {
 26 | 	size_t length = wcslen(s);
 27 | 	wchar_t* ws = new wchar_t[length + 1];
 28 | 	ws[length] = 0;
 29 | 	for(size_t i = 0; i < length; ++i)
 30 | 		ws[i] = s[i];
 31 | 	return ws;
 32 | }
 33 | 
 34 | //static const wchar_t* copy_string(const KString& s)
 35 | //{
 36 | //	return copy_string(s.c_str());
 37 | //}
 38 | 
 39 | 
 40 | //KString::KString(const KString& value)
 41 | //	: s_(copy_string(value)
 42 | //	, size_(value.size())
 43 | //{
 44 | //	
 45 | //}
 46 | 
 47 | 
 48 | 
 49 | KString::KString(const char* s)
 50 | 	: s_(copy_string(s))
 51 | 	  , size_(strlen(s))
 52 | {
 53 | 	
 54 | }
 55 | 
 56 | KString::KString(const wchar_t* s)
 57 | 	: s_(copy_string(s))
 58 | 	  , size_(wcslen(s))
 59 | {}
 60 | 
 61 | KString::KString(const KString& s)
 62 | 	: s_(copy_string(s.s_))
 63 | 	  , size_(s.size())
 64 | {
 65 | }
 66 | 
 67 | 
 68 | 
 69 | size_t KString::size()const
 70 | {
 71 | 	return size_;
 72 | }
 73 | 
 74 | 
 75 | wchar_t KString::operator[](size_t index)const
 76 | {
 77 | 	return s_[index];
 78 | }
 79 | 
 80 | KString& KString::operator=(const KString& value)
 81 | {
 82 | 	if (&value == this)
 83 | 		return *this;
 84 | 	delete [] s_;
 85 | 	s_ = copy_string(value.c_str());
 86 | 	size_ = value.size();
 87 | 	return *this;
 88 | }
 89 | 
 90 | KString operator+(const KString& left, const KString& right)
 91 | {
 92 | 	KString temp;// = 
 93 | 	size_t length = left.size() + right.size();
 94 | 	temp.s_ = new wchar_t[length + 1];
 95 | 	temp.size_ = length;
 96 | 	wcscpy(temp.s_, left.c_str());
 97 | 	wcscat(temp.s_, right.c_str());
 98 | 	return temp;
 99 | }
100 | 
101 | //KString operator+=(const KString& left, const KString& right)
102 | //{
103 | //	left = left + right;
104 | //	return left;
105 | //}
106 | 
107 | 
108 | KString::~KString()
109 | {
110 | 	if (s_ != NULL)
111 | 		delete [] s_;
112 | }
113 | 
114 | bool operator!=(const KString& left, const KString& right)
115 | {
116 | 	return left != right;
117 | }
118 | 
119 | bool operator==(const KString& left, const KString& right)
120 | {
121 | 	if (left.c_str() == right.c_str())
122 | 		return true;
123 | 	if (left.size() != right.size())
124 | 		return false;
125 | 	for(size_t i = 0; i < left.size(); ++i)
126 | 		if (left[i] != right[i])
127 | 			return false;
128 | 	return true;
129 | }
130 | 
131 | 
132 | //KString& KString::operator+(const KString& left, const KString& right)
133 | //{
134 | //	right;
135 | //	return left;
136 | //}
137 | 


--------------------------------------------------------------------------------
/KString.h:
--------------------------------------------------------------------------------
 1 | #ifndef __KSTIRNG__H
 2 | #define __KSTIRNG__H
 3 | 
 4 | #include <cstddef>
 5 | 
 6 | 
 7 | class KString
 8 | {
 9 | 	public:
10 | 		KString();
11 | 		KString(const char*);
12 | 		KString(const wchar_t*);
13 | 		KString(const KString&);
14 | 		KString& operator=(const KString&);
15 | 		~KString();
16 | 	private:
17 | 		wchar_t* s_;
18 | 		size_t size_;
19 | 	public:
20 | 		size_t size()const;
21 | 		const wchar_t* c_str()const
22 | 		{ return s_; }	
23 | 		wchar_t operator[](size_t) const;
24 | 		bool operator!=(const KString& right);
25 | 		friend KString operator+(const KString&, const KString&);
26 | };
27 | 
28 | 
29 | //KString operator+=(const KString& left, const KString&);
30 | bool operator==(const KString& left, const KString& right);
31 | 
32 | 
33 | 
34 | 
35 | #endif//__KSTIRNG__H
36 | 


--------------------------------------------------------------------------------
/KUnicodeString.cpp:
--------------------------------------------------------------------------------
  1 | #include "KUnicodeString.h"
  2 | 
  3 | void assignZero(UNICODE_STRING* uStr)
  4 | {
  5 | 	uStr->Buffer = 0;
  6 | 	uStr->Length = 0;
  7 | 	uStr->MaximumLength = 0;
  8 | }
  9 | 
 10 | KUnicodeString::KUnicodeString()
 11 | 	: str_(NULL)
 12 | 	  , size_(0)
 13 | {
 14 | 	assignZero(&uStr_);
 15 | }
 16 | 
 17 | KUnicodeString::~KUnicodeString()
 18 | {
 19 | 	if (str_)
 20 | 		delete [] str_;
 21 | 	if (uStr_.Buffer)
 22 | 		delete [] uStr_.Buffer;
 23 | }
 24 | 
 25 | KUnicodeString::KUnicodeString(const char* s)
 26 | {
 27 | 	size_t length = strlen(s);
 28 | 	str_ = new wchar_t[length + 1];
 29 | 	for(size_t i = 0; i < length + 1; ++i)
 30 | 		str_[i] = s[i];
 31 | 	size_ = length;
 32 | 	assignZero(&uStr_);
 33 | }
 34 | 
 35 | KUnicodeString::KUnicodeString(const wchar_t* s)
 36 | {
 37 | 	size_t length = wcslen(s);
 38 | 	str_ = new wchar_t[length + 1];
 39 | 	for(size_t i = 0; i < length + 1; ++i)
 40 | 		str_[i] = s[i];
 41 | 	size_ = length;
 42 | 	assignZero(&uStr_);
 43 | }
 44 | 
 45 | static void copy_unicode(PWSTR* uString, const KUnicodeString& kString)
 46 | {
 47 | 	wchar_t* temp = new wchar_t[kString.size() + 1];
 48 | 	for(size_t i = 0; i < kString.size() + 1; ++i)
 49 | 		temp[i] = kString[i];
 50 | 	*uString = temp;
 51 | }
 52 | 
 53 | KUnicodeString::KUnicodeString(const KUnicodeString& s)
 54 | {
 55 | 	copy_unicode(&str_, s);
 56 | 	size_ = s.size();
 57 | 	uStr_ = s.uStr_;
 58 | }
 59 | 
 60 | KUnicodeString& KUnicodeString::operator=(const KUnicodeString& s)
 61 | {
 62 | 	copy_unicode(&str_, s);
 63 | 	size_ = s.size();
 64 | 	assignZero(&uStr_);
 65 | 	return *this;
 66 | }
 67 | 
 68 | KUnicodeString operator+(const KUnicodeString& left, const KUnicodeString& right)
 69 | {
 70 | 	KUnicodeString temp;
 71 | 	size_t length = left.size() + right.size();
 72 | 	temp.str_ = new wchar_t[length + 1];
 73 | 	//temp.str_[length] = 0;
 74 | 	wcscpy(temp.str_, left.c_str());
 75 | 	wcscat(temp.str_, right.c_str());
 76 | 	temp.size_ = left.size() + right.size();
 77 | 	assignZero(&temp.uStr_);
 78 | 	return temp;
 79 | }
 80 | 
 81 | bool operator==(const KUnicodeString& left, const KUnicodeString& right)
 82 | {
 83 | 	if (&left == &right)
 84 | 		return true;
 85 | 	if (left.size() != right.size())
 86 | 		return false;
 87 | 	for(size_t i = 0; i < left.size() + 1; ++i)
 88 | 		if (left[i] != right[i])
 89 | 			return false;
 90 | 	return true;
 91 | }
 92 | 
 93 | bool operator!=(const KUnicodeString& left, const KUnicodeString& right)
 94 | {
 95 | 	return !(left == right);
 96 | }
 97 | 
 98 | //KUnicodeString& KUnicodeString::operator+=(const KUnicodeString& right)
 99 | //{
100 | //	*this = *this + right;
101 | //	return *this;
102 | //}
103 | 
104 | static void copy_unicodestring(UNICODE_STRING* uStr, PWSTR str)
105 | {
106 | 	if (uStr->Buffer)
107 | 		delete [] uStr->Buffer;
108 | 	size_t length = wcslen(str);
109 | 	uStr->Buffer = new wchar_t[length + 1];
110 | 	uStr->Length = uStr->MaximumLength = length;
111 | }
112 | 
113 | const UNICODE_STRING KUnicodeString::toUnicodeString()
114 | {
115 | 	copy_unicodestring(&uStr_, str_);
116 | 	return uStr_;
117 | }
118 | 
119 | const UNICODE_STRING* KUnicodeString::getUnicodeString()
120 | {
121 | 	copy_unicodestring(&uStr_, str_);
122 | 	return &uStr_;
123 | }
124 | 
125 | 
126 | 
127 | 
128 | 


--------------------------------------------------------------------------------
/KUnicodeString.h:
--------------------------------------------------------------------------------
 1 | #ifndef __KUNICODESTRING__H
 2 | #define __KUNICODESTRING__H
 3 | 
 4 | #include <windows.h>
 5 | 
 6 | struct UNICODE_STRING
 7 | {
 8 | 	USHORT Length;
 9 | 	USHORT MaximumLength;
10 | 	PWSTR  Buffer;
11 | };
12 | 
13 | 
14 | class KUnicodeString
15 | {
16 | 	public:
17 | 		KUnicodeString();
18 | 		KUnicodeString(const char*);
19 | 		KUnicodeString(const wchar_t*);
20 | 		KUnicodeString(const KUnicodeString&);
21 | 		KUnicodeString& operator=(const KUnicodeString&);
22 | 		~KUnicodeString();
23 | 	public:
24 | 		friend KUnicodeString operator+(const KUnicodeString&, const KUnicodeString&);
25 | 		//KUnicodeString& operator+=( const KUnicodeString&);
26 | 		friend bool operator==(const KUnicodeString&, const KUnicodeString&);
27 | 		friend bool operator!=(const KUnicodeString&, const KUnicodeString&);
28 | 	public:
29 | 		const UNICODE_STRING toUnicodeString();
30 | 		const UNICODE_STRING* getUnicodeString();
31 | 	public:
32 | 		size_t size()const
33 | 		{
34 | 			return size_;
35 | 		}
36 | 
37 | 		const PWSTR c_str()const
38 | 		{ return str_; }
39 | 	public:
40 | 		wchar_t operator[](size_t index)
41 | 		{ return str_[index]; }
42 | 		const wchar_t operator[](size_t index)const
43 | 		{ return str_[index];}
44 | 	private:
45 | 		PWSTR str_;
46 | 		size_t size_;
47 | 	private:
48 | 		UNICODE_STRING uStr_;
49 | 
50 | };
51 | 
52 | #endif//__KUNICODESTRING__H
53 | 


--------------------------------------------------------------------------------
/KVector.cpp:
--------------------------------------------------------------------------------
1 | #include "KVector.h"
2 | 


--------------------------------------------------------------------------------
/KVector.h:
--------------------------------------------------------------------------------
 1 | #ifndef __KVECTOR__H
 2 | #define __KVECTOR__H
 3 | 
 4 | #include <cstddef>
 5 | 
 6 | template<typename type>
 7 | class KVector
 8 | {
 9 | 	public:
10 | 		KVector()
11 | 			: t_(0)
12 | 			, size_(0)
13 | 		{
14 | 		}
15 | 
16 | 		explicit KVector(size_t count)
17 | 		{
18 | 			t_ = new type[count];
19 | 			size_ = count;
20 | 		}
21 | 
22 | 		~KVector()
23 | 		{
24 | 			if (t_ != NULL)
25 | 				delete [] t_;
26 | 		}
27 | 	private:
28 | 		type* t_;
29 | 		size_t size_;
30 | 	public:
31 | 		size_t size()
32 | 		{ return size_; }
33 | 
34 | 		type& operator[](size_t index)
35 | 		{
36 | 			return t_[index];
37 | 		}
38 | 		const type operator[](size_t index)const
39 | 		{
40 | 			return t_[index];
41 | 		}
42 | };
43 | 
44 | #endif//__KVECTOR__H
45 | 


--------------------------------------------------------------------------------
/SharedPointer.h:
--------------------------------------------------------------------------------
 1 | #ifndef __SHAREDPOINTER__H
 2 | #define __SHAREDPOINTER__H
 3 | 
 4 | #include <cstddef>
 5 | 
 6 | template<typename T>
 7 | class SharedPointer
 8 | {
 9 | 	private:
10 | 		T* t_;
11 | 		size_t* count_;
12 | 	public:
13 | 		SharedPointer()
14 | 			: t_(0)
15 | 			  ,count_(0)
16 | 		{}
17 | 
18 | 		SharedPointer(T* t)
19 | 			: t_(t)
20 | 			  , count_(new size_t(1))
21 | 		{}
22 | 
23 | 		SharedPointer(const SharedPointer& other)
24 | 			: t_(other.t_)
25 | 			  , count_(0)
26 | 		{
27 | 			++*other.count_;
28 | 			count_ = other.count_;
29 | 		}
30 | 
31 | 		~SharedPointer()
32 | 		{
33 | 			release();
34 | 		}
35 | 
36 | 	public:
37 | 		void reset()
38 | 		{
39 | 			release();
40 | 		}
41 | 
42 | 		size_t reference()
43 | 		{
44 | 			return *count_;
45 | 		}
46 | 	public:
47 | 		T* get()
48 | 		{
49 | 			return t_;
50 | 		}
51 | 
52 | 		T* operator->()
53 | 		{
54 | 			return t_;
55 | 		}
56 | 
57 | 		T& operator*()
58 | 		{
59 | 			return *t_;
60 | 		}
61 | 	private:
62 | 		void release()
63 | 		{
64 | 			if (!t_)
65 | 				return;
66 | 			--(*count_);
67 | 			if (*count_ != 0)
68 | 				return;
69 | 			delete count_;
70 | 			delete t_;
71 | 		}
72 | 
73 | };
74 | #endif//__SHAREDPOINTER__H
75 | 


--------------------------------------------------------------------------------
/main.cpp:
--------------------------------------------------------------------------------
 1 | #include "KString.h"
 2 | #include "KVector.h"
 3 | #include "SharedPointer.h"
 4 | #include "KUnicodeString.h"
 5 | 
 6 | #include <iostream>
 7 | void testKString()
 8 | {
 9 | 	KString ks("wstring");
10 | 	KString kws("WSTRING");
11 | 	std::wcout << ks.c_str() << std::endl;
12 | 	std::wcout << kws.c_str() << std::endl;
13 | 	KString s = ks + kws;
14 | 	std::wcout << s.c_str() << std::endl;
15 | }
16 | 
17 | class Person
18 | {
19 | 	public:
20 | 		Person()
21 | 		{ std::cout << "Constructor" << std::endl;}
22 | 		~Person()
23 | 		{ std::cout << "Decontructor" << std::endl;}
24 | };
25 | 
26 | void testVector()
27 | {
28 | 	KVector<int> vec(5);
29 | 	for(size_t i = 0; i < vec.size(); ++i)
30 | 	{
31 | 		vec[i] = i + 1;
32 | 	}
33 | 
34 | 	for(size_t i = 0; i < vec.size(); ++i)
35 | 	{
36 | 		std::cout << vec[i];
37 | 	}
38 | 	std::cout << std::endl;
39 | }
40 | 
41 | void testPointer()
42 | {
43 | 	SharedPointer<Person> p1(new Person);
44 | 	SharedPointer<Person> p2 = p1;
45 | 	SharedPointer<Person> p3 = p2;
46 | 	std::cout << "reference:" << p1.reference() << std::endl;
47 | }
48 | 
49 | void testUnicode()
50 | {
51 | 	KUnicodeString ss("abcdefg");
52 | 	KUnicodeString ws("ABCDEFG");
53 | 	std::wcout << ss.c_str() << std::endl;
54 | 	std::wcout << ws.c_str() << std::endl;
55 | 	KUnicodeString ws2 = ws;
56 | 	std::wcout << ws2.c_str() << std::endl;
57 | 	std::wcout << ws2.size() << std::endl;
58 | 	KUnicodeString s = ss + ws;
59 | 	std::wcout << s.c_str() << std::endl;
60 | 	KUnicodeString cs("abcdefg");
61 | 	std::wcout << L"compare:" << (cs == ss) << std::endl;
62 | 	std::wcout << L"compare:" << (cs != ss )<< std::endl;
63 | 	
64 | }
65 | 
66 | int main(int, char**)
67 | {
68 | 	testKString();
69 | 	testVector();
70 | 	testPointer();
71 | 	testUnicode();
72 | 	return 0;
73 | }
74 | 


--------------------------------------------------------------------------------