Design Pattern

Както в повечето ИТ компании и в Chaos имаме собствена библиотечка.
Книжката по-долу обаче получи специално внимание, и бе покръстена така веднага щом я докараха :D.

Ако трябва да сме честни, това четивo може и да е полезно. Чувал съм да го ползват като не-толкова-добра ракета за тенис на маса, например.

п.с. every problem can be solved using one more abstraction layer, except too many abstraction layers … or javascript-like performance.

Lets talk C++

Има едно видео за скриптовите езици, което бая ме забавлява :).
Аз се порових, stackoverflow и из стар код. Та.

C++;

auto str = "Let's talk C++";
auto strLength = strlen(str);
std::cout << strLength << " ... " << std::endl;
if (strLength < -1) 
    std::cout << "WAT." << std::endl;

auto str = "Let's talk C++";

auto strLength = strlen(str);

std::cout << strLength << " ... " << std::endl;

if (strLength < -1)

std::cout << "WAT." << std::endl;

Резултат: 14 … WAT.

strlen връща size_t, което бидейки unsigned по стандарт, каства -1 до unsigned, което е всъщност едно доста голямо число :).
if (strLength < -1.f) обаче работи както трябва (понеже по стандарт се каства до най-големия тип с плаваща запетая, ако има такъв).

C++; 11;

auto  a = new int(42);
auto* b = new int(196);
bool starsAreImportant = strcmp(typeid(a).name(), typeid(b).name()) != 0;
if (starsAreImportant == false)
   std::cout << "WAT.";

auto a = new int(42);

auto* b = new int(196);

bool starsAreImportant = strcmp(typeid(a).name(), typeid(b).name()) != 0;

if (starsAreImportant == false)

std::cout << "WAT.";

аuto като feature ползва механизма на template-ите за определяне на типа. Звездичката, която седи там е безсмислена, но може да я има.

C++;

int *ptr, value = NULL;
if (ptr) *ptr = 42; //crash here
value = ptr; //compilation error here
std::cout << (value + 42); //works fine ...
std::cout << "WAT";

int *ptr, value = NULL;

if (ptr) *ptr = 42; //crash here

value = ptr; //compilation error here

std::cout << (value + 42); //works fine ...

std::cout << "WAT";

На първият ред декларираме int* ptr, и int value = NULL – което е все едно:
int* ptr;int value = 0; … Неинициализиран ptr и int със стойност 0. nullptr решава част от недоразумението.

C++;

int i = -1;
std::cout << (i >> 1) << " WAT.";

1 2	int i = -1; std::cout << (i >> 1) << " WAT.";

Недефинирна резултат … Cтандарта указва какво влияние имат битовите операции върху signed типове. В по-голямата си част са undefined, а в другата е доста оплетено.

C++;

int main() {
    http://code-bg.com
    std::cout << "WAT.";
    return 0;
}

int main() {

http://code-bg.com

std::cout << "WAT.";

return 0;

}

Това се компилира. То е етикет за goto с име http, а след него има коментар code-bg.com

C++;

struct Storage {
    static int const value = 42;
};

template<typename T>
void bar(T const&){}
int main() {
    bar(Storage::value);//compile time error
    bar(+Storage::value);//fine
    std::cout << "WAT.";
}

struct Storage {

static int const value = 42;

};

template<typename T>

void bar(T const&){}

int main() {

bar(Storage::value);//compile time error

bar(+Storage::value);//fine

std::cout << "WAT.";

}

Унарният оператор + създава копие :).

C++;

volatile int* ptr = new int;
std::cout << ptr; //always prints 1

1 2	volatile int* ptr = new int; std::cout << ptr; //always prints 1

std::cout няма предефиниран оператор с volatile .. А понеже всеки указател може да се конвертира до bool, в случая това се случва ..

Останалите за друг път.
А за бонус, този ред:

typedef int (*(Foo::*bar())[196]);

1	typedef int ((Foo::bar())[196]);

typedef bits

Наскоро докато ровех из нета срещнах идеята за user defined literal _bits, а днес ми остана време да го напиша.
В общи линии, идеята е safe & fast обръщане на двоично число в десетично, например на 11000100 в 196, без намесата на програмист.
Ето и въпросния код.

typedef unsigned long long uint64;
//compile time big endian to unsigned long long
template<char head, char... tail>
struct big_endian_to_uint {
    static_assert(head >= '0' && head <='1', "Invalid bits in operator\"\"_bits big_endian_to_uint<>");
    
    const static uint64 value = (head - '0') +
                                2 * (big_endian_to_uint<tail...>::value);
};

template<char head>
struct big_endian_to_uint<head> {
    static_assert(head >= '0' && head <='1', "Invalid bits in operator\"\"_bits big_endian_to_uint<>");
    
    const static uint64 value = (head - '0');
};

//**************************************
//compile time little endian to unsigned long long
template<char head, char... tail>
struct little_endian_to_uint {
    static_assert(head >= '0' && head <='1', "Invalid bits in operator\"\"_bits little_endian_to_uint<>");
    
    const static uint64 value = (1 << sizeof...(tail)) * (head - '0') +
                                (little_endian_to_uint<tail...>::value);
};

template<char head>
struct little_endian_to_uint<head> {
    static_assert(head >= '0' && head <='1', "Invalid bits in operator\"\"_bits little_endian_to_uint<>");

    const static uint64 value = (head - '0');
};

//**************************************
template<char... chars>
constexpr uint64 operator"" _bits(){
    //endianess check available
    /*const static int i = 1;
    const static char c = * ((char *)(&i));
    const static bool is_little_endian = i == c;
    if (is_little_endian)
        return little_endian_to_uint<chars...>::value;
    else
        return big_endian_to_uint<chars...>::value;
    */
    return little_endian_to_uint<chars...>::value;
}

int main(){
    std::cout << 101010_bits;
}

typedef unsigned long long uint64;

//compile time big endian to unsigned long long

template<char head, char... tail>

struct big_endian_to_uint {

static_assert(head >= '0' && head <='1', "Invalid bits in operator\"\"_bits big_endian_to_uint<>");

const static uint64 value = (head - '0') +

2 * (big_endian_to_uint<tail...>::value);

};

template<char head>

struct big_endian_to_uint<head> {

static_assert(head >= '0' && head <='1', "Invalid bits in operator\"\"_bits big_endian_to_uint<>");

const static uint64 value = (head - '0');

};

//**************************************

//compile time little endian to unsigned long long

template<char head, char... tail>

struct little_endian_to_uint {

static_assert(head >= '0' && head <='1', "Invalid bits in operator\"\"_bits little_endian_to_uint<>");

const static uint64 value = (1 << sizeof...(tail)) * (head - '0') +

(little_endian_to_uint<tail...>::value);

};

template<char head>

struct little_endian_to_uint<head> {

static_assert(head >= '0' && head <='1', "Invalid bits in operator\"\"_bits little_endian_to_uint<>");

const static uint64 value = (head - '0');

};

//**************************************

template<char... chars>

constexpr uint64 operator"" _bits(){

//endianess check available

/*const static int i = 1;

const static char c = * ((char *)(&i));

const static bool is_little_endian = i == c;

if (is_little_endian)

return little_endian_to_uint<chars...>::value;

else

return big_endian_to_uint<chars...>::value;

return little_endian_to_uint<chars...>::value;

}

int main(){

std::cout << 101010_bits;

}

С този оператор, можем да пишем неща като int i = 1000_bits; и i ще има стойност 8.
Става compile time, прави проверки за валидност, намалява възможноста за някои грешки, а и се чете лесно :).

Const life

Натъкнах се на поредно ново 20 вчера 🙂
Една от често срещаните грешки, когато човек започва да пише на С++ е код като този :

int& getInt() {
    int i = 196;
    return i;
}

int& getInt() {

int i = 196;

return i;

}

Псевдоним към temporary, то няма да съществува след като функцията е била извикана и това ще бъде undefined behavior (най-вероятно кофти краш).
Лесно и ясно, но.

//credit http://goo.gl/sZn9k Alexandrescu, Sutter & Co
#include <iostream>
#include <string>

//contains logged c'tors
struct LoggedString {
    LoggedString(std::string rhs):str(rhs) {
        std::cout << "LoggedString()" << std::endl;
    }
    LoggedString(const LoggedString& rhs) {
        std::cout << "const LoggedString& rhs" << std::endl;
        str = rhs.str;
    }
    LoggedString(LoggedString&& rhs) {
        std::cout << "LoggedString&& rhs" << std::endl;
        str = std::move(rhs.str);
    }
    LoggedString& operator=(const LoggedString& rhs){
        std::cout << "operator=const LoggedString& rhs" << std::endl;
        str = rhs.str;
        return *this;
    }
    LoggedString& operator=(LoggedString&& rhs) {
        std::cout << "operator=LoggedString&& rhs" << std::endl;
        str = std::move(rhs.str);
        return *this;
    }
    ~LoggedString() {
        std::cout << "~LoggedString() " << str << std::endl;
    }
    
    //
    std::string str;
};

LoggedString getLoggedString() {
    return {"42"};
}

void mostImportantConst() {
    const auto& magic = getLoggedString(); //(1)
    std::cout << magic.str << std::endl; //(2)
    
    const_cast<LoggedString&>(magic).str[0] = '5'; //(3)
    std::cout << magic.str << std::endl;
    
    std::cout << "**********\n";
    auto antiMagic = getLoggedString(); //(4)
    //antiMagic = std::move(const_cast<LoggedString&>(magic)); //(5)
    std::cout << "**********\n";
    
    //auto& badMagic = getLoggedString(); //(6)
}

int main(){
    mostImportantConst();
}

//credit http://goo.gl/sZn9k Alexandrescu, Sutter & Co

#include <iostream>

#include <string>

//contains logged c'tors

struct LoggedString {

LoggedString(std::string rhs):str(rhs) {

std::cout << "LoggedString()" << std::endl;

}

LoggedString(const LoggedString& rhs) {

std::cout << "const LoggedString& rhs" << std::endl;

str = rhs.str;

}

LoggedString(LoggedString&& rhs) {

std::cout << "LoggedString&& rhs" << std::endl;

str = std::move(rhs.str);

}

LoggedString& operator=(const LoggedString& rhs){

std::cout << "operator=const LoggedString& rhs" << std::endl;

str = rhs.str;

return *this;

}

LoggedString& operator=(LoggedString&& rhs) {

std::cout << "operator=LoggedString&& rhs" << std::endl;

str = std::move(rhs.str);

return *this;

}

~LoggedString() {

std::cout << "~LoggedString() " << str << std::endl;

}

std::string str;

};

LoggedString getLoggedString() {

return {"42"};

}

void mostImportantConst() {

const auto& magic = getLoggedString(); //(1)

std::cout << magic.str << std::endl; //(2)

const_cast<LoggedString&>(magic).str[0] = '5'; //(3)

std::cout << magic.str << std::endl;

std::cout << "**********\n";

auto antiMagic = getLoggedString(); //(4)

//antiMagic = std::move(const_cast<LoggedString&>(magic)); //(5)

std::cout << "**********\n";

//auto& badMagic = getLoggedString(); //(6)

}

int main(){

mostImportantConst();

}

В (1) изглежда вземаме ref към temp, и в (2) следва да имаме проблем. Това обаче не е съвсем така.
С++ някъде из стандарта, ясно указва че const следва да удължи живота на temporary-тата 🙂 Без static, без копия.
Така, не само можем да изпълним (2), но (3) също работи.
(4) създаваме нов LoggedString, само за да видим по-късно кога неговият деструктор ще се извика.
Нещо повече, и двата компилатора, които имам дори не ми позволяват да компилирам (6).
Другото което видях, е че не са малко на брой редовете, които трябва да бъдат изписани за да имаме прост клас, дефиниран с всички необходими конструктори …
Output :

LoggedString()
42
52
**********
LoggedString()
**********
~LoggedString() 42
~LoggedString() 52

LoggedString()

**********

LoggedString()

**********

~LoggedString() 42

~LoggedString() 52

C(++)onstructors

Ето една проста С++(98) конструкция, която не рядко се бърка. Хора ползващи Java или друг език в миналото си, и С++ в настоящето си се сблъскват с това :

class Foo {
public:
    Foo(){
       bar = 42;
       printf("Foo()\n");
    }

    Foo(int) {
       buzz = 196;
       Foo();
       printf("Foo(int); %i %i", bar, buzz);
    }

private:
    int bar;
    int buzz;
};

int main() {
    Foo foo(411);
}

class Foo {

public:

Foo(){

bar = 42;

printf("Foo()\n");

}

Foo(int) {

buzz = 196;

Foo();

printf("Foo(int); %i %i", bar, buzz);

}

private:

int bar;

int buzz;

};

int main() {

Foo foo(411);

}

На пръв поглед това не трябва да се компилира. Имаме контруктор, който вика друг конструктор (и ползваме C++ < 11). А това не е разрешено в тази версия на езика (макар не всички да го знаят). За да е тотално объркването обаче, всеки компилатор успява да го компилира без грешки. Този код работи и не нарушава стандарта. Не прави обаче съвсем това, което човек би очаквал.

printf("Foo(int); %i %i", bar, buzz); //Foo(int); <undefined> 196

1	printf("Foo(int); %i %i", bar, buzz); //Foo(int); <undefined> 196

Причината за това е, че Foo() не вика конструктора за обекта, който се конструира във Foo(int), а създава temporary object (без име) !

За по ясно, вместо Foo(); там може да пише int(); … така ще сме създали един int на стека, който както и Foo(); ще спре да съществува след като излезем от scope-а на Foo(int). Може да стане по-ясно, ако добавим деструктор, в който има само printf.

~Foo() { 
    printf("~Foo()\n");
}

~Foo() {

printf("~Foo()\n");

}

Можем обаче да накараме нещата да сработят .. Ако ползваме placement new, бихме могли да извикаме конструктура върху обекта, който очакваме. Ето така :

Foo(int) {
    buzz = 196;
    new (this) Foo(); //here be dragons
    printf("Foo(int); %i %i", bar, buzz);
}

Foo(int) {

buzz = 196;

new (this) Foo(); //here be dragons

printf("Foo(int); %i %i", bar, buzz);

}

Показаното по-горе работи (поне в gcc, clang && cl). Но не е съвсем гарантирано, че ще работи навсякъде и винаги. Добрият стар init() метод е по-подходящ тогава.

Смятай …

TeraFlops, here we come.

typename Google

E Google … можеше просто да споделиш че харесваш C++ meta programming …
No need for harsh words, r8 …

Some cache misses

По повод лекцията на Бярне от началото на годината, и едно леко почесване по главата по време на работа преди няколко дни на тема, лоши ли са кеш-мисовете и имат ли те почва у нас, реших днес да проверя от първа ръка 🙂

Ето една проста задачка с интересни резултати 🙂

Имаме масив с N целочислени числа от 0 до N-1, записани в произволен ред.

Искаме да намерите i-тото от тях, да гo изтрием, но да запазим реда им.
Но вместо i-тото, да вземем да изтрием всички от 0 до N-1 и да ги изтрием едно по-едно .. Питаме се каква структура от данни да ползваме, така че това да се случи най-бързо.

Та, обичайните кандидати .. линеен масив и свързан списък. Свързаният списък изглежда по-обещаващ, вместо да копираме всеки път, само ще меним разни поинтъри.

Правим тестове със std::vector, std::list, custom vector && custom list (кода се намира по-долу)
За да е по-къса цялата лудория, имплементирал съм само методите, които са нужни за демонстрацията (няма деструктури и т.н.). Съобщавайте ако има major грешки в коментарите по-долу.

#include <iostream>
#include <string>
#include <sstream>
#include <cstdlib>
#include <ctime>
#include <vector>
#include <list>
 
double diffclock(clock_t clock1,clock_t clock2){
	double diffticks = clock1 - clock2;
	return (diffticks) / CLOCKS_PER_SEC;
}
 
template <typename T>
class List {
public:
    List():first(nullptr), last(nullptr){}
 
    bool empty() const {
        return first == nullptr;
    }
 
    bool add(T data) {
        Node* newNode = new Node(data);
        if (first == nullptr) {
            last = first = newNode;
        } else {
            last->next = newNode;
            newNode->prev = last;
            newNode->next = nullptr;
            last = newNode;
        }
        return true;
    }
 
    bool remove(T data) {
        Node* temp = first;
        while (temp && temp->data != data)
            temp = temp->next;
 
        if (!temp) return false;
        if (temp == first) {
            Node* newFirst = first->next;
            delete first;
            if (newFirst) newFirst->prev = nullptr;
            first = newFirst;
        } else if (temp == last) {
            Node* newLast = last->prev;
            delete last;
            if (newLast) newLast->next = nullptr;
            last = newLast;
        } else {
            Node* left = temp->prev;
            Node* right = temp->next;
            delete temp;
            left->next = right;
            right->prev = left;
        }
        return true;
    }
private:
    struct Node {
        Node(T dataRhs):data(dataRhs), prev(nullptr), next(nullptr){}
        T data;
        Node* prev;
        Node* next;
    };
 
    Node* first;
    Node* last;
};
 
template <typename T>
class Vector {
public:
    Vector():ptr(nullptr), index(0), maxSize(0){}
 
    bool empty() const {
        return index == 0;
    }
 
    bool reset(int newSize) {
        delete[] ptr;
        ptr = new T[newSize];
        maxSize = newSize;
        return true;
    }
 
    bool add(T data) {
        if (index == maxSize) return false;
        ptr[index++] = data;
        return true;
    }
 
    bool remove(T data) {
        int remIndex = -1;
        for (int i = 0; i < maxSize; ++i) {
            if (ptr[i] == data)  {
                remIndex = i;
                break;
            };
        }
        if (remIndex == -1) return false;
 
        memmove(&ptr[remIndex], &ptr[remIndex + 1], maxSize - remIndex);
        --index;
        return true;
    }
private:
    T* ptr;
    int index;
    int maxSize;
};
 
const int SIZE = 81000;
 
template <typename T>
void eraseContainer(T& container) {
    for (int i = 0; i < SIZE; ++i)
        container.remove(i);
}
 
template <typename T>
void eraseContainer(std::vector<T>& vec) {
    for (int i = 0; i < SIZE; ++i) {
        auto iter = std::find(vec.begin(), vec.end(), i);
        vec.erase(iter);
    }
}
 
double stdVecTime = 0.0;
double stdListTime = 0.0;
double customVecTime = 0.0;
double customListTime = 0.0;
 
void test() {
    std::vector<int> vecStd;
    vecStd.reserve(SIZE);
    for (int i = 0; i < SIZE; ++i)
        vecStd.push_back(i);
 
    std::random_shuffle(vecStd.begin(), vecStd.end());
 
    using namespace std;
    std::list<int> listStd;
    for (int i = 0; i < SIZE; ++i)
        listStd.push_back(vecStd[i]);
 
    Vector<int> vecCustom;
    vecCustom.reset(SIZE);
    for (int i = 0; i < SIZE; ++i) 
        vecCustom.add(vecStd[i]);
 
    List<int> listCustom;
    for (int i = 0; i < SIZE; ++i)
        listCustom.add(vecStd[i]);
 
    clock_t beginStdVec = clock();
    eraseContainer(vecStd);
    clock_t endStdVec = clock();
    stdVecTime+= double(diffclock(endStdVec,beginStdVec));
	if(!vecStd.empty()) printf("Bug in std vector test\n");
 
    clock_t beginStdList = clock();
    eraseContainer(listStd);
    clock_t endStdList = clock();
    stdListTime += double(diffclock(endStdList,beginStdList));
    if(!listStd.empty()) printf("Bug in std list test\n");   
 
    clock_t beginVec = clock();
    eraseContainer(vecCustom);
    clock_t endVec = clock();
    customVecTime += double(diffclock(endVec,beginVec)) ;
	if(!vecCustom.empty()) printf("Bug in custom vector test\n");
 
    clock_t beginList = clock();
    eraseContainer(listCustom);
    clock_t endList = clock();
    customListTime += double(diffclock(endList,beginList));
    if(!listCustom.empty()) printf("Bug in custom list test\n");
}
 
int main(int argc, const char * argv[]) {
    const double testTimes = 1.0;
    srand((unsigned)time(0));
    for (int i = 0; i < testTimes; ++i)
        test();
 
    std::cout << "Std vec time:" << stdVecTime / testTimes << std::endl;
    std::cout << "Std list time:" << stdListTime / testTimes << std::endl;
    std::cout << "Custom vec time:" << customVecTime / testTimes << std::endl;
    std::cout << "Custom list time:" << customListTime / testTimes<< std::endl;
 
    return 0;
}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

#include <iostream>

#include <string>

#include <sstream>

#include <cstdlib>

#include <ctime>

#include <vector>

#include <list>

double diffclock(clock_t clock1,clock_t clock2){

double diffticks = clock1 - clock2;

return (diffticks) / CLOCKS_PER_SEC;

}

template <typename T>

class List {

public:

List():first(nullptr), last(nullptr){}

bool empty() const {

return first == nullptr;

}

bool add(T data) {

Node* newNode = new Node(data);

if (first == nullptr) {

last = first = newNode;

} else {

last->next = newNode;

newNode->prev = last;

newNode->next = nullptr;

last = newNode;

}

return true;

}

bool remove(T data) {

Node* temp = first;

while (temp && temp->data != data)

temp = temp->next;

if (!temp) return false;

if (temp == first) {

Node* newFirst = first->next;

delete first;

if (newFirst) newFirst->prev = nullptr;

first = newFirst;

} else if (temp == last) {

Node* newLast = last->prev;

delete last;

if (newLast) newLast->next = nullptr;

last = newLast;

} else {

Node* left = temp->prev;

Node* right = temp->next;

delete temp;

left->next = right;

right->prev = left;

}

return true;

}

private:

struct Node {

Node(T dataRhs):data(dataRhs), prev(nullptr), next(nullptr){}

T data;

Node* prev;

Node* next;

};

Node* first;

Node* last;

};

template <typename T>

class Vector {

public:

Vector():ptr(nullptr), index(0), maxSize(0){}

bool empty() const {

return index == 0;

}

bool reset(int newSize) {

delete[] ptr;

ptr = new T[newSize];

maxSize = newSize;

return true;

}

bool add(T data) {

if (index == maxSize) return false;

ptr[index++] = data;

return true;

}

bool remove(T data) {

int remIndex = -1;

for (int i = 0; i < maxSize; ++i) {

if (ptr[i] == data) {

remIndex = i;

break;

};

}

if (remIndex == -1) return false;

memmove(&ptr[remIndex], &ptr[remIndex + 1], maxSize - remIndex);

--index;

return true;

}

private:

T* ptr;

int index;

int maxSize;

};

const int SIZE = 81000;

template <typename T>

void eraseContainer(T& container) {

for (int i = 0; i < SIZE; ++i)

container.remove(i);

}

template <typename T>

void eraseContainer(std::vector<T>& vec) {

for (int i = 0; i < SIZE; ++i) {

auto iter = std::find(vec.begin(), vec.end(), i);

vec.erase(iter);

}

double stdVecTime = 0.0;

double stdListTime = 0.0;

double customVecTime = 0.0;

double customListTime = 0.0;

void test() {

std::vector<int> vecStd;

vecStd.reserve(SIZE);

for (int i = 0; i < SIZE; ++i)

vecStd.push_back(i);

std::random_shuffle(vecStd.begin(), vecStd.end());

using namespace std;

std::list<int> listStd;

for (int i = 0; i < SIZE; ++i)

listStd.push_back(vecStd[i]);

Vector<int> vecCustom;

vecCustom.reset(SIZE);

for (int i = 0; i < SIZE; ++i)

vecCustom.add(vecStd[i]);

List<int> listCustom;

for (int i = 0; i < SIZE; ++i)

listCustom.add(vecStd[i]);

clock_t beginStdVec = clock();

eraseContainer(vecStd);

clock_t endStdVec = clock();

stdVecTime+= double(diffclock(endStdVec,beginStdVec));

if(!vecStd.empty()) printf("Bug in std vector test\n");

clock_t beginStdList = clock();

eraseContainer(listStd);

clock_t endStdList = clock();

stdListTime += double(diffclock(endStdList,beginStdList));

if(!listStd.empty()) printf("Bug in std list test\n");

clock_t beginVec = clock();

eraseContainer(vecCustom);

clock_t endVec = clock();

customVecTime += double(diffclock(endVec,beginVec)) ;

if(!vecCustom.empty()) printf("Bug in custom vector test\n");

clock_t beginList = clock();

eraseContainer(listCustom);

clock_t endList = clock();

customListTime += double(diffclock(endList,beginList));

if(!listCustom.empty()) printf("Bug in custom list test\n");

}

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

const double testTimes = 1.0;

srand((unsigned)time(0));

for (int i = 0; i < testTimes; ++i)

test();

std::cout << "Std vec time:" << stdVecTime / testTimes << std::endl;

std::cout << "Std list time:" << stdListTime / testTimes << std::endl;

std::cout << "Custom vec time:" << customVecTime / testTimes << std::endl;

std::cout << "Custom list time:" << customListTime / testTimes<< std::endl;

return 0;

}

Компилатора е LLVM4.1 с всички оптимизации, процесора – Core2Duo 2.26ghz (P8400), MacOS 10.8.1. Структурите custom vec && custom list всъщност не са от значение, тъй като най-често ни интересуват резултатите от std (написах ги от носталгия, след като завърших хората спряха да ме карат да ги пиша непрекъснато)
Ето и резултатите (lower is better). Замерванията са правени по 3 пъти, показано е средно аритметичното:

По всичко личи, че моя вектор не е много бърз. Това е добре, имплементацията не изглежда много грешна, но пък е бавна. +1 за STL-a 🙂
И понеже никой не харесва таблици, ето ги в арт вариант :

И понеже не се виждат тези в началото заради скалирането, ето ги и тях :

Не ми се мисли, разни езици от високо ниво, пазещи програмистите от “странични ефекти на кода {}”, ползващи за пестене на памет разни линкчета насам-натам колко бързо работят 🙂

Изглежда че vector е the silver bullet (и не е вярно, че ако има честа нужда от махане на елементи в средата list-a върши работата екстра), а и че за тези неща трябва да се говори в университета, че срамота така завършваме неуки …

MultiHassle Programming

What CUDA/OpenCL programming is like …

Git

Вижда се, Git има няколко функции, които обикновените клавиатури не предлагат, но има и някои особености при натискане на Return key-a. Пръстите на Линус изглежда са тънки.

blOgo

Blago's Blog

Design Pattern

Lets talk C++

typedef bits

Const life

C(++)onstructors

Смятай …

typename Google

Some cache misses

MultiHassle Programming

Git