[CPP] Add std::string::operator+=(...)

Author: scopeInfinity

src/usr/include/string.h

@@ -34,16 +34,29 @@ class basic_string {
     std::vector<CharT> _data;
 
 public:
+    typedef CharT* iterator;
+    typedef const CharT* const_iterator;
+
     basic_string();
     basic_string(std::size_t n, CharT c);
     basic_string(const CharT* str);
     basic_string(const CharT* str, std::size_t n);
 
+    iterator begin();
+    iterator end();
+    const_iterator begin() const;
+    const_iterator end() const;
+
+    void pop_back();
     CharT& back();
     CharT& front();
     CharT& at(std::size_t pos);
     CharT& operator[](std::size_t pos);
     const CharT *c_str() const;
+
+    basic_string<CharT>& operator+=(const CharT c);
+    basic_string<CharT>& operator+=(const CharT* o);
+    basic_string<CharT>& operator+=(const basic_string<CharT> &o);
 };
 
 using string = basic_string<char>;

src/usr/include/string.tcc

@@ -22,14 +22,33 @@ basic_string<CharT>::basic_string(const CharT* str) : _data(std::strlen(str)+1,
 }
 
 template <typename CharT>
-basic_string<CharT>::basic_string(const CharT* str, std::size_t n) {
+basic_string<CharT>::basic_string(const CharT* str, std::size_t n) : _data(n+1, '\0') {
     int str_n = std::strlen(str);
-    this->_data(n+1, '\0');
     for (std::size_t i = 0; i < n && i < str_n; i++) {
         this->_data[i] = str[i];
     }
 }
 
+template <typename CharT>
+typename basic_string<CharT>::iterator basic_string<CharT>::begin() { return this->_data.begin(); }
+
+template <typename CharT>
+typename basic_string<CharT>::iterator basic_string<CharT>::end() { return this->_data.end() - 1; }
+
+template <typename CharT>
+typename basic_string<CharT>::const_iterator basic_string<CharT>::begin() const { return this->_data.begin(); }
+
+template <typename CharT>
+typename basic_string<CharT>::const_iterator basic_string<CharT>::end() const { return this->_data.end() - 1; }
+
+template <typename CharT>
+void basic_string<CharT>::pop_back() {
+    if(this->_data.size()>1) {
+        this->_data.pop_back();
+        this->_data.last() = '\0';
+    }
+}
+
 template <typename CharT>
 CharT& basic_string<CharT>::back() {
     return this->_data.at(this->_data.size()-2);
@@ -52,7 +71,34 @@ CharT& basic_string<CharT>::operator[](std::size_t pos) {
 
 template <typename CharT>
 const CharT *basic_string<CharT>::c_str() const {
-    return this->_data.raw_data();
+    return this->_data.begin();
+}
+
+template <typename CharT>
+basic_string<CharT>& basic_string<CharT>::operator+=(const CharT c) {
+    this->_data.back() = c;  // replace null character
+    this->_data.push_back('\0');  // add null character
+    return *this;
+}
+
+template <typename CharT>
+basic_string<CharT>& basic_string<CharT>::operator+=(const CharT* o) {
+    this->_data.pop_back();  // remove null character
+    while ((*o))  {
+        this->_data.push_back(*(o++));
+    }
+    this->_data.push_back('\0');  // add null character
+    return *this;
+}
+
+template <typename CharT>
+basic_string<CharT>& basic_string<CharT>::operator+=(const basic_string<CharT> &o) {
+    this->_data.pop_back();  // remove null character
+    for(const CharT &c: o) {
+        this->_data.push_back(c);
+    }
+    this->_data.push_back('\0');  // add null character
+    return *this;
 }
 
 } // namespace std end

src/usr/include/vector.h

@@ -11,9 +11,17 @@ class vector {
     void resize_capacity(std::size_t capacity);
 
 public:
+    typedef T* iterator;
+    typedef const T* const_iterator;
+
     vector<T>();
     vector<T>(std::size_t size, const T &_default);
 
+    iterator begin();
+    iterator end();
+    const_iterator begin() const;
+    const_iterator end() const;
+
     T *raw_data() const;
     bool empty();
     std::size_t size();

src/usr/include/vector.tcc

@@ -30,23 +30,30 @@ vector<T>::vector(std::size_t size, const T &_default): _size(size)  {
     }
 }
 
+template <typename T>
+typename vector<T>::iterator vector<T>::begin() { return this->_data; }
+
+template <typename T>
+typename vector<T>::iterator vector<T>::end() { return this->_data + this->_size; }
+
+template <typename T>
+typename vector<T>::const_iterator vector<T>::begin() const { return this->_data; }
+
+template <typename T>
+typename vector<T>::const_iterator vector<T>::end() const { return this->_data + this->_size; }
+
 template <typename T>
 void vector<T>::resize_capacity(std::size_t capacity) {
     // internal; assumes capacity to be power of 2
     // and will also make a copy of array and move _data pointer.
     // assumes size<=current_capacity and size<=new_capacity
-    this->_capacity = capacity;
     const std::size_t data_size = capacity*sizeof(T);
     T *_new_data = (T*) std::malloc(data_size);
     if (!_new_data) return;  // malloc failed
     std::memcpy(_new_data, this->_data, data_size);
     std::free(this->_data);  // should be no-op if _data == NULL
     this->_data = _new_data;
-}
-
-template <typename T>
-T *vector<T>::raw_data() const {
-    return this->_data;
+    this->_capacity = capacity;
 }
 
 template <typename T>

src/usr/local/src/simplecpp.cpp

@@ -60,11 +60,15 @@ int main(int argc, char *argv[]) {
     printShapeDetails(&r1);
     printShapeDetails(&s1);
 
-    // name
+    // new, delete and std::string
     char *name = new char[1024];
     std::cout << "Enter your name: ";
     std::cin >> name;
-    std::cout << "Your name is: " << name << std::endl;
+    std::string cool_name;
+    cool_name += '[';
+    cool_name += name;
+    cool_name += ']';
+    std::cout << "Your name is: " << cool_name << std::endl;
     delete[] name;
 
     // vector
@@ -74,10 +78,6 @@ int main(int argc, char *argv[]) {
         std::cout << "list[" << (int)i << "] = " << list[i] << std::endl;
     }
 
-    // std::string
-    std::string cpp_string("i am c++ string");
-    std::cout << "Out: " << cpp_string << std::endl;
-
     std::cout << "Exiting..." << std::endl;
     return 0;
 }