refactored code, made new comments, extended manualtest.cpp, commented

out tests of unimplemented stuff in test.cpp
This commit is contained in:
Kjistóf 2016-10-26 16:37:18 +02:00
parent c1254caf25
commit 5711cb6096
8 changed files with 72 additions and 51 deletions

View File

@ -1,5 +1,4 @@
#include "Char.h"
#include <cstring>

1
Char.h
View File

@ -1,4 +1,5 @@
#pragma once
#include <cstring>
#include "String.h"
class String;
class StringValue;

View File

@ -1,7 +1,4 @@
#include "String.h"
#include "Char.h"
#include <cstring>
#include <memory>
@ -46,59 +43,70 @@ void swap(String& s1, String& s2) noexcept
swap(s1._str, s2._str);
}
String::String(String&& other) noexcept : String() // init via default ctor so _str is a nullptr
String::String(String&& other) noexcept
:String() // init via default ctor so _str is a nullptr
{ swap(*this, other); }
String String::operator+(const String& rhs) const
{
auto size = this->size() + rhs.size() + 1; // plus a null-terminator
auto data = new char[size]; // make some space
std::strcpy(data, this->c_str()); // copy data of this
auto data = this->copy_and_concat(rhs);
String ret;
ret._str = new StringValue(std::strcat(data, rhs.c_str())); // append data of rsh
ret._str = new StringValue(data); // build new String from data
return ret;
}
String& String::operator+=(const String& other)
String& String::operator+=(const String& rhs)
{
auto size = this->size() + other.size() + 1; // plus a null-terminator
auto data = new char[size];
std::strcpy(data, this->c_str()); // copy our data
std::strcat(data, other.c_str()); // append data of the other string
auto data = this->copy_and_concat(rhs);
_str->operator--(); // release old data
_str = new StringValue(data);
_str = new StringValue(data); // create new
return *this;
}
String String::operator+(char c) const
// copies this and concats str
char* String::copy_and_concat(const String& str) const
{
auto data = new char[this->size() + 2]; // new char + null terminator
std::strcpy(data, this->c_str());
data[this->size()] = c;
data[this->size()+1] = '\0';
auto size = this->size() + str.size() + 1; // plus a null-terminator
auto data = new char[size]; // make some space
std::strcpy(data, this->c_str()); // copy data of this
std::strcat(data, str.c_str()); // concat str
return data;
}
String String::operator+(char rhs) const
{
auto data = this->copy_and_concat(rhs);
String ret;
ret._str = new StringValue(data);
ret._str = new StringValue(data); // build new String from data
return ret;
}
String& String::operator+=(char c)
String& String::operator+=(char rhs)
{
auto data = new char[this->size() + 2]; // new char + null terminator
std::strcpy(data, this->c_str());
data[this->size()] = c;
data[this->size()+1] = '\0';
auto data = this->copy_and_concat(rhs);
_str->operator--();
_str = new StringValue(data);
_str->operator--(); // release old data
_str = new StringValue(data); // create new
return *this;
}
// copies this and concats c
char* String::copy_and_concat(char c) const
{
auto data = new char[this->size() + 2]; // plus new char & null terminator
std::strcpy(data, this->c_str()); // copy data of this
data[this->size()] = c; // concats c
data[this->size() + 1] = '\0'; // null-terminator
return data;
}
bool String::operator==(const String& other) const
{
if (_str)
@ -112,14 +120,12 @@ const char& String::operator[](size_t index) const
if (_str)
return (const_cast<const StringValue*>(_str))->operator[](index); // cast to use const operator[]
else
throw std::runtime_error("You cannot index an uninitialized String!");
throw std::runtime_error("You cannot uninitialized Strings!");
}
// reuse const operator[]
// reuse const operator[], just as Scott Meyers would
Char String::operator[](size_t index)
{
return Char(_str->index_of(&const_cast<char&>(const_cast<const String*>(this)->operator[](index))), *this);
}
{ return Char(_str->index_of(&const_cast<char&>(const_cast<const String*>(this)->operator[](index))), *this); }
size_t String::size() const noexcept
{
@ -134,7 +140,7 @@ const char* String::c_str() const
if (_str)
return *_str; // invokes StringValue::operator const char*()
else
throw std::runtime_error("You cannot get the content of an uninitialized string!");
throw std::runtime_error("You cannot get the content of uninitialized Strings!");
}
std::istream& operator>>(std::istream& is, String& str)
@ -157,7 +163,7 @@ std::istream& operator>>(std::istream& is, String& str)
if (str._str) // if there is some old data, release it
str._str->operator--();
str._str = new StringValue(data.release()); // release ownership of final data
str._str = new StringValue(data.release()); // get ownership of final data
return is;
}

View File

@ -1,5 +1,7 @@
#pragma once
#include <iostream>
#include <cstring>
#include <memory>
#include "StringValue.h"
#include "Char.h"
class Char;
@ -16,6 +18,9 @@ private:
StringValue* _str;
char* copy_and_concat(const String& str) const;
char* copy_and_concat(char c) const;
public:
String() noexcept;

View File

@ -1,6 +1,4 @@
#include "StringValue.h"
#include <stdexcept>
#include <cstring>
@ -30,6 +28,7 @@ const char& StringValue::operator[](size_t index) const
return _data[index];
}
// reuse const operator[], just as Scott Meyers would
char& StringValue::operator[](size_t index)
{ return const_cast<char&>(const_cast<const StringValue*>(this)->operator[](index)); }
@ -41,8 +40,8 @@ size_t StringValue::size() const noexcept
size_t StringValue::index_of(char* c) const
{
size_t index = c - _data; // this is totally safe pointer-arithmetic
if (index <= this->size()) // if it is within our data
size_t index = c - _data; // this is totally safe as long as I don't do anything with it
if (index <= this->size()) // if it is within our data it is safe to use
return index;
else
throw std::invalid_argument("char* not within held data!");

View File

@ -1,5 +1,6 @@
#pragma once
#include <stddef.h>
#include <stdexcept>
#include <cstring>

View File

@ -7,21 +7,30 @@
/* This is a demonstration, that the String class and it's components work
* correctly, basically a non-unit test. */
* correctly, basically a non-unit test. Perfect for usage with valgrind */
int main()
{
if (std::is_default_constructible<String>::value)
std::cout << "class String is default constructible" << std::endl;
String defaultctor();
if (std::is_constructible<String, const char*>::value)
std::cout << "class String is constructible from const char*" << std::endl;
String constchar("yeeeey");
if (std::is_copy_constructible<String>::value)
std::cout << "class String is copy constructible" << std::endl;
String copy(constchar);
if (std::is_copy_assignable<String>::value)
std::cout << "class String is copy assignable" << std::endl;
String othercopy;
othercopy = constchar;
if (std::is_move_constructible<String>::value)
std::cout << "class String is move constructible" << std::endl;
String moved(std::move(othercopy));
if (std::is_move_assignable<String>::value)
std::cout << "class String is move assignable" << std::endl;
String moveassigned;
moveassigned = std::move(moved);
std::cout << std::endl;

View File

@ -204,7 +204,8 @@ TEST_P(ResourceSharingStringTest, resourceSharingWorks)
EXPECT_EQ(str1.c_str(), str2.c_str());
}
INSTANTIATE_TEST_CASE_P(tests, ResourceSharingStringTest, ::testing::ValuesIn(testvalues3));
// this feature is not implemented yet, therefore needs no testing
//INSTANTIATE_TEST_CASE_P(tests, ResourceSharingStringTest, ::testing::ValuesIn(testvalues3));
// Stream tests