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

blOgo

Blago's Blog

June 2013

Lets talk C++

typedef bits

Const life