How to... C++

[Belphegor]

@Ivan

Ok. Mada mislim da je kod ocigledan.

class random
...

Dosadile mi srand i rand funkcije, a rek'o i da probam ovaj Mersenne Twister generator pa sam to lepo spakovao u klasu.
Klasa ima templejt metodu get overload-ovanu da bih u zavisnosti od tipa argumenata koristio odgovarajuce "distribucije".
Znaci samo integral i floating-point tipovi dolaze u obzir sve ostalo je compile time error.

http://en.cppreference.com/w/cpp/num...t_distribution

typedef std::pair<std::size_t, std::size_t> tpnum;
    std::vector<tpnum> numbers;

Imam vektor parova gde prvi element (first) oznacava koliko puta se ponovio neki broj i drugi element (second) oznacava sam taj broj.

numbers.resize(N);

        std::for_each(std::begin(numbers), std::end(numbers), [](tpnum& e){
            e = std::make_pair(0u, random::get(0u, 100u));
        });

Prosirujem vektor na velicinu N (koliko brojeva se izvlaci) i inicijalizujem ga. first = 0, second = random 0 - 100.

for(auto& it : numbers)
        {
            it.first = std::count_if(std::begin(numbers), std::end(numbers), [&it](const tpnum& e){
                return it.second == e.second;
            });
        }

Broji koliko se koji element ponavlja (tu su i "duplikati") i cuvam tu vrednost za svaki.

std::sort(std::begin(numbers), std::end(numbers), [](const tpnum& l, const tpnum& r){
            return l.second > r.second;
        });

Soriram po random brojevima koji su izvuceni da bih u sledecem koraku imao vektor spreman za unique-ifikaciju (std::unique).

auto end = std::unique(std::begin(numbers), std::end(numbers), [](const tpnum& l, const tpnum& r){
            return l.second == r.second;
        });

Pozivam std::unique algo i cuvam end iterator da bih znao gde je kraj unikatima.

std::sort(std::begin(numbers), end, [](const tpnum& l, const tpnum& r){
            return l.first > r.first;
        });

Sortiram ponovo da bih dobio elemente koje se najvise ponavljaju prvo. Od pocetka do elementa gde pokazuje end iterator.

I na kraju ispisujem prvih F elemenata. Mada moze da se desi da broj unikata bude manji od F-a ali nece fejlovati.

[ivan90BG]

Pa dobro, jeste tačno, mada malo opskurno. Ali šta ako se traži veliki broj ponavljanja, koliki je i potreban da bi ispitivanje imalo statističku vrednost. Recimo nekoliko desetina hiljada. Uporedi performanse. Rakun_s_Neonkom je dao najbolji način za vođenje broja ponavljanja iz koga prirodno proizilazi samo jedno jedino sortiranje i kraj.

[ivan90BG]

Ima li neko predstavu zašto bi linker bacao grešku da ne može da nađe destruktor nadklase (pozvan je iz destruktora podklase), ako je pri tom taj destruktor označen sa "=0" (cela klasa je interfejs). Kompajler ne bi trebalo ni da ubacuje poziv za destruktor nad klase ako je pure virtual.

[voodoo_]

Da nije ovo?

http://stackoverflow.com/questions/2...ass-destructor

[ivan90BG]

OK, razumeo, čak i ako je pure virtual destruktor mora da ima implementaciju. ( koja koincidencija, i meni se ovo dešava na Mac OS X-u sa GCC 4.2).

[voodoo_]

To si ti i postavio, samo da proveriš naš googling skillz

[voodoo_]

Neke fore i fazoni za optimizaciju C i C++ koda (nije baš najsvežije, ali ima dosta toga korisnog):

http://www.tantalon.com/pete/cppopt/main.htm

[Andross]

Imam problem sa templejtima posto ne mogu nigde da nadjem krsten primer za ono sto meni treba. Elem imam Vec2D klasu koja je templejt i kod je sledeci:

#ifndef VEC2D_HPP_INCLUDED
#define VEC2D_HPP_INCLUDED

#include <cmath>

template <typename T>
class Vec2d
{
public:
    // Constructor
    Vec2d();
    Vec2d(T x, T y);
    Vec2d(const Vec2d& v);

    // Methods
    T GetLength();
    Vec2d GetNormalized();

    // Operators
    Vec2d& operator=(const Vec2d& v);
    Vec2d& operator+=(const Vec2d& v);
    Vec2d& operator-=(const Vec2d& v);
    Vec2d& operator*=(const T s);
    Vec2d& operator/=(const T s);
    const Vec2d operator+(const Vec2d& v) const;
    const Vec2d operator-(const Vec2d& v) const;
    const Vec2d operator*(const T s)const;
    const Vec2d operator/(const T s)const;
    bool operator==(const Vec2d& v);
    bool operator!=(const Vec2d& v);

    // Member variables
    T X;
    T Y;

    // Static members
    static Vec2d Zero;
};

#endif // VEC2D_HPP_INCLUDED

#include "Vec2d.hpp"

// Static member initialization
template <typename T>
Vec2d<T>::Zero = Vec2d<T>();

// Constructor
template <typename T>
Vec2d<T>::Vec2d()
{
    X = 0;
    Y = 0;
}

template <typename T>
Vec2d<T>::Vec2d(T x, T y)
{
    X = x;
    Y = y;
}

template <typename T>
Vec2d<T>::Vec2d(const Vec2d& v)
{
    X = v.X;
    Y = v.Y;
}

// Method implementation
template <typename T>
T Vec2d<T>::GetLength()
{
    return sqrt(X * X + Y * Y);
}

template <typename T>
Vec2d<T> Vec2d<T>::GetNormalized()
{
    float len = GetLength();
    return Vec2d<T>(X / len, Y / len);
}

// Operator implementation
template <typename T>
Vec2d<T>& Vec2d<T>::operator=(const Vec2d& v)
{
    if(this != &v)
    {
        X = v.X;
        Y = v.Y;
    }

    return *this;
}

template <typename T>
Vec2d<T>& Vec2d<T>::operator+=(const Vec2d& v)
{
    X += v.X;
    Y += v.Y;
    return *this;
}

template <typename T>
Vec2d<T>& Vec2d<T>::operator-=(const Vec2d& v)
{
    X -= v.X;
    Y -= v.Y;
    return *this;
}

template <typename T>
Vec2d<T>& Vec2d<T>::operator*=(const T s)
{
    X *= s;
    Y *= s;
    return *this;
}

template <typename T>
Vec2d<T>& Vec2d<T>::operator/=(const T s)
{
    X /= s;
    Y /= s;
    return *this;
}

template <typename T>
const Vec2d<T> Vec2d<T>::operator+(const Vec2d& v) const
{
    return Vec2d<T>(*this) += v;
}

template <typename T>
const Vec2d<T> Vec2d<T>::operator-(const Vec2d& v) const
{
    return Vec2d<T>(*this) -= v;
}

template <typename T>
const Vec2d<T> Vec2d<T>::operator*(const T s) const
{
    return Vec2d<T>(*this) *= s;
}

template <typename T>
const Vec2d<T> Vec2d<T>::operator/(const T s) const
{
    return Vec2d<T>(*this) /= s;
}

template <typename T>
bool Vec2d<T>::operator==(const Vec2d& v)
{
    if(X == v.X && Y == v.Y)
        return true;

    return false;
}

template <typename T>
bool Vec2d<T>::operator!=(const Vec2d& v)
{
    return !(*this == v);
}

Sada prilikom kompajliranja dobijam sledecu gresku: need 'typename' before 'Vec2d<T>::Zero' because 'Vec2d<T>' is a dependent scope

Ukoliko uklonim staticku promenljivu, kompajl prodje fino i prilikom linkovanja popijem gomilu undefined reference gresaka.

Moja pitanja:

1. Gde sve pisem <T>? Kod povratne vrednosti i imena klase ciji metod implementiram i nigde vise?

2. Kako inicijalizujem staticku promenljivu templejta? Jel potrebno da pravim specijalizaciju za int, float i ostale tipove koje budem nameravao da koristim (videh negde da se to radi)?

3. Zbog cega se pojavljuju undefined reference greske i kako ih ukloniti?

[Belphegor]

Dok ne budes dobio detaljniji odgovor od nekog da probam ja da pomognem.

2. Sintaksa je:

template < typename T >
typename Vec2d<T>::Vec2d Vec2d<T>::Zero = Vec2d<T>();

Da ne ulazim zasto (Google "c++ template class implementation"), obicno kod templejt klasa iplementacija metoda se pravi u samom telu te klase.

Evo ti recimo za operatore "uporedjivanja" (g++ 4.7), ovi operatori trebaju isto da budu const posto ne menjaju clanove klase.

#include <type_traits>
...
template < typename T >
class Vec2d
{
    // primamo samo odredjene tipove templejta Vec2d
    // ostalo je compile time error
    static_assert( std::is_floating_point<T>::value || std::is_integral<T>::value, "Unacceptable type for Vec2d!");
public:
    Vec2d() : x(0), y(0) {}
    Vec2d(T _x, T _y) : x(_x), y(_y) {}

    template < typename U >
    typename std::enable_if< std::is_floating_point<T>::value || std::is_floating_point<U>::value, bool >::type
    operator == (const Vec2d<U>& o) const
    {
        if((std::fabs(x - o.x) > 0.00001) || (std::fabs(y - o.y) > 0.00001))
        {
            return false;
        }
        return true;
    }

    template < typename U >
    typename std::enable_if< std::is_integral<T>::value && std::is_integral<U>::value, bool >::type
    operator == (const Vec2d<U>& o) const
    {
        return x == o.x && y == o.y;
    }

    bool operator != (const Vec2d<T>& o) const
    {
        return !(*this == o);
    }

    T x, y;
    static Vec2d<T> Zero;
};

Overload operatora == zbog uporedjivanja floating point brojeva.

3. Daj celu poruku za sta kuka.

[Andross]

Hvala za ovo.
Linker errore sam resio instanciranjem templejt klasa posto mi je implementacija i dalje odvojena, a koristicu samo odredjene tipove za T:

template class Vec2d<int>;
template class Vec2d<float>;

Edit: Jos 2 pitanja:

1. Zasto si koristio typename U za operator ==
2. Koja je fora sa const pre i posle funkcije? Tipa const a(); b() const; const c() const;

[Geomaster]

Andross kaže:

Hvala za ovo.
Linker errore sam resio instanciranjem templejt klasa posto mi je implementacija i dalje odvojena, a koristicu samo odredjene tipove za T:

template class Vec2d<int>;
template class Vec2d<float>;

Edit: Jos 2 pitanja:

1. Zasto si koristio typename U za operator ==
2. Koja je fora sa const pre i posle funkcije? Tipa const a(); b() const; const c() const;

Na ovo prvo pitanje ne umem da odgovorim, Belph je koristio gomilu onih ogavnih stvari iz standardne biblioteke, nije mi sve najjasnije.
2. Const pre funkcije označava da je povratna vrednost funkcije konstantna tj. da se ne može menjati. Const posle funkcije znači da funkcija ne može da menja stanje klase u kojoj se nalazi, pa može da se poziva i iz const objekata te klase. Na primer:

class cls {
public:
  int member1, member2;

  void do_something() { member1 = 40; member2 = 20; }
  int do_something_const() const { return member1*member2; } /* ne menja stanje klase */
};

...
  const cls a;
  cls b;
  int x = a.do_something_const(); /* može, jer je funkcija const */
  b.do_something(); /* može, funkcija nije const ali nije ni objekat */
  a.do_something(); /* greška, objekat je const a funkcija nije! */
...

[Belphegor]

1. Zato sto nisam mogao drugacije da overloadujem taj operator na kontu samo T-a, a usput side-effect je da sad mogu da se porede Vec2d razlicith tipova:

typedef Vec2d<double> vd;
typedef Vec2d<int> vi;
...
vd v0(0.2, 3.6);
vi v1(5, 1);
if(v0 == v1)
...

2. Ima slucajeva da se desi da moras menjati neki clan klase u "post const" metodi, onda ga oznacis kao mutable.

class Foo
{
mutable int data;
float data2;
...
float metod() const
{
    data = 5;// sad je dozvoljeno
    return data2;
}
};

[Alek92]

Pozdrav narode,

I nakon dugog pretrazivanja, nisam uspeo da nadjem ono sto me zanima:

da li postoji nacin (i koji je to nacin) da ispisem tekst na ekran u boji po zelji, na osnovu R,G,B vrednosti?

(Uspevao sam da nadjem razne enume i slicne nacine, ali to mi nije prakticno)

Hvala u svakom slucaju !

[Belphegor]

Evo ti za pocetak:

#define WIN32_LEAN_AND_MEAN
#include <Windows.h>
#include <string>

typedef std::basic_string<TCHAR> tstring;

const tstring helloStr = TEXT("hello");
const tstring worldStr = TEXT("world");

LRESULT CALLBACK WindowProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
    switch(msg)
    {
    case WM_PAINT:
        {
            PAINTSTRUCT ps;
            HDC hdc = BeginPaint(hWnd, &ps);

            SetBkMode(hdc, TRANSPARENT);

            SetTextColor(hdc, RGB(200,0,100));
            TextOut(hdc, 10, 10, helloStr.c_str(), helloStr.size());

            SetTextColor(hdc, RGB(0,100,50));
            TextOut(hdc, 10, 30, worldStr.c_str(), worldStr.size());

            EndPaint(hWnd, &ps);
            return 0;
        }break;
    case WM_DESTROY:
        {
            PostQuitMessage(0);
            return 0;
        }break;
    };
    return DefWindowProcW(hWnd, msg, wParam, lParam);
}

int WINAPI WinMain(HINSTANCE hinstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow)
{
    WNDCLASS wndClass;
    memset(&wndClass, 0, sizeof(WNDCLASS));
    wndClass.hInstance     = GetModuleHandle(0);
    wndClass.style         = CS_HREDRAW | CS_VREDRAW;
    wndClass.lpfnWndProc   = WindowProc;
    wndClass.hCursor       = LoadCursor(NULL, IDC_ARROW);
    wndClass.lpszClassName = TEXT("TextTestClass");
    wndClass.hbrBackground = GetSysColorBrush(COLOR_3DFACE);

    DWORD style = WS_SYSMENU | WS_BORDER | WS_CAPTION | WS_CLIPSIBLINGS | WS_MINIMIZEBOX | WS_THICKFRAME;
    style |= WS_VISIBLE;

    if(0 == RegisterClass(&wndClass))
    {
        MessageBox(0, TEXT("RegisterClass() failed!"), 0, 0);
        return 1;
    }

    RECT clientSize;
    clientSize.top    = 0;
    clientSize.left   = 0;
    clientSize.right  = 200;
    clientSize.bottom = 100;
    AdjustWindowRect(&clientSize, style, FALSE);
    int realWidth  = clientSize.right - clientSize.left;
    int realHeight = clientSize.bottom - clientSize.top;
    int windowLeft = (GetSystemMetrics(SM_CXSCREEN) - realWidth) / 2;
    int windowTop  = (GetSystemMetrics(SM_CYSCREEN) - realHeight) / 2;

    HWND hwnd = CreateWindowEx(0,
        TEXT("TextTestClass"), TEXT("Text test"), style,              
        windowLeft, windowTop, realWidth, realHeight,
        NULL, NULL, GetModuleHandle(0), NULL);
    if(nullptr == hwnd)
    {
        MessageBox(0, TEXT("CreateWindowEx() failed!"), 0, 0);
        return 1;
    }

    ShowWindow(hwnd, SW_SHOW);
    UpdateWindow(hwnd);

    MSG  msg   = {0};
    while(GetMessage(&msg, NULL, 0, 0))
    {
        TranslateMessage(&msg);
        DispatchMessage(&msg);
    }
    
    return 0;
}

[ivan90BG]

A sada nešto neviđeno

class Foo
{
protected:
	struct Data
	{
		int var;
	};

	Foo::Data* d;
private:
	Foo(Foo::Data* dptr);
public:
	static Foo New();
	Foo(Foo& other);
};

Foo::Foo(Foo::Data *dptr): d(dptr) {}
Foo::Foo(Foo& other): d(other.d) {}

Foo Foo::New()
{
	return Foo(new Foo::Data);
}

int main()
{
	Foo foo = Foo::New();
	return 0;
}

Kompajler (GCC) daje grešku:

main.cpp:26: error: no matching function for call to 'Foo::Foo(Foo)'
linija 26 je u funkciji New(), a istu grešku javlja i za main() funkciju.

Šta mu dođe ovo, copy constructor by value (što nema smisla). Ako stvarno dodam konstruktor Foo(Foo other) kompajler se buni. Izgleda kao da mu nešto fali, pa on prelazi na neki praistorijski default koga nema. Ima li neko ideju šta ovde nedostaje.

Da nije možda stvar u tome što pri vraćanju objekata mora da se pozove copy constructor koji uzima referencu, a reference se mogu napraviti samo na neprivremene objekte. Mada čisto sumnjam.

EDIT: Otkrio, copy constructor mora da uzima const& da bi mogao da radi sa privremenim objektima, šta ti je ovaj C++

[Night Walker]

Ljudi, treba mi pomoc oko stringova.
Kako da uporedim string zapamcen u nizu od 15 karaktera sa nekim konstantnim stringom?
Skontao sam da mogu da uporedjujem skaki pojedinacni karakter
(if (ff[0]=='T' && itd... do '\0'))
Ali to je naporno jer ima mnogo konstantnih stringova sa kojim treba uporediti.
Moze tako da radi jedino ako napravim funkciju u koja ce da uporedjuje 2 stringa koja jos se posalju, ali sigurno postoji jednostavniji nacin, zar ne?

[Teva]

http://www.cplusplus.com/reference/c...string/strcmp/

[voodoo_]

Radi sigurnosti, koristi strncmp (kao treći argument prosledi dužinu prvog stringa od 15 karaktera).

[Ozzy]

Jel bi mogao neko da mi za ovaj algoritam tj kod da mi napise ulaz i izlaz tj da program moze da cita sa standardnog ulaza i izbacuje resenje na standardni izraz. Ja bi to sam uradio al neki delovi mi nisu bas jasni pa ce mi ovako biti lakse da posmatram posle u kompajleru korak po korak sta program radi pa da razumem. Hvala unapred

#include <string>
#include <cctype>

using namespace std;

class Parser
{
    string input;
    bool isValid;

    bool isEnd(size_t pos) const
    {
        return pos >= input.size();
    }

    bool readChar(size_t &pos, char c) const
    {
        if (isEnd(pos) || input[pos] != c) {
            return false;
        }

        ++pos;

        return true;
    }

    bool readString(size_t &pos, const string &str) const
    {
        if (input.substr(pos, str.size()) != str) {
            return false;
        }

        pos += str.size();

        return true;
    }

    bool isLetter(size_t pos) const
    {
        return isEnd(pos) == false && isalpha(input[pos]);
    }

    bool isAlphanumeric(size_t pos) const
    {
        return isEnd(pos) == false && isalnum(input[pos]);
    }

    bool readPropositionalLetter(size_t &pos) const
    {
        if (isLetter(pos) == false) {
            return false;
        }

        do {
            ++pos;
        } while (isLetter(pos));

        return true;
    }

    bool readSubformula(size_t &pos) const
    {
        if (isEnd(pos)) {
            return false;
        }

        if (readChar(pos, '-')) {
            return readSubformula(pos);
        }

        if (readChar(pos, '(')) {
            return readSubformula(pos) && readChar(pos, '>') && readSubformula(pos) && readChar(pos, ')');
        }

        return readPropositionalLetter(pos);
    }

    bool findImplication(size_t &pos) const
    {
        int brackets = 0;

        for (; isEnd(pos) == false; ++pos) {
            if (brackets == 0 && input[pos] == '>') {
                ++pos;

                return true;
            }

            if (input[pos] == '(') {
                ++brackets;
            } else if (input[pos] == ')') {
                --brackets;
            }
        }

        return false;
    }

public:
    Parser(const string &input) :
        input(input)
    {
        size_t pos = 0;

        if (readSubformula(pos) == false) {
            isValid = false;

            return;
        }

        if (isEnd(pos)) {
            isValid = true;

            return;
        }

        pos = 0;

        isValid = readSubformula(pos) && readChar(pos, '>') && readSubformula(pos) && isEnd(pos);
    }

    bool axiom1() const
    {
        if (isValid == false) {
            return false;
        }

        if (input.size() >= 2 && input[0] == '(' && input[input.size() - 1] == ')') {
            Parser tmp(input.substr(1, input.size() - 2));

            if (tmp.axiom1()) {
                return true;
            }
        }

        size_t pos = 0;

        if (findImplication(pos) == false) {
            return false;
        }

        string a = input.substr(0, pos - 1);

        return readChar(pos, '(') && findImplication(pos) && readString(pos, a + ")") && isEnd(pos);
    }

    bool axiom2() const
    {
        if (isValid == false) {
            return false;
        }

        if (input.size() >= 2 && input[0] == '(' && input[input.size() - 1] == ')') {
            Parser tmp(input.substr(1, input.size() - 2));

            if (tmp.axiom2()) {
                return true;
            }
        }

        size_t pos = 0;

        if (readChar(pos, '(') == false || findImplication(pos) == false) {
            return false;
        }

        string a = input.substr(1, pos - 2);

        if (readChar(pos, '(') == false || findImplication(pos) == false) {
            return false;
        }

        string b = input.substr(a.size() + 3, pos - a.size() - 4);

        pos = 0;

        if (findImplication(pos) == false) {
            return false;
        }

        string c = input.substr(a.size() + b.size() + 4, pos - a.size() - b.size() - 7);

        return readString(pos, string("((") + a + ">" + b + ")>(" + a + ">" + c + "))") && isEnd(pos);
    }

    bool axiom3() const
    {
        if (isValid == false) {
            return false;
        }

        size_t pos = 0;

        if (readString(pos, "((")) {
            Parser tmp(input.substr(1, input.size() - 2));

            return tmp.axiom3();
        }

        if (readString(pos, "(-") == false || findImplication(pos) == false) {
            return false;
        }

        string b = input.substr(2, pos - 3);

        pos = 0;

        if (findImplication(pos) == false) {
            return false;
        }

        string a = input.substr(b.size() + 4, pos - b.size() - 6);

        return readString(pos, string("(") + a + ">" + b + ")") && isEnd(pos);
    }
};

[M.Silenus]

Ovako nešto:

#include <iostream>
#include <iomanip>
#include <iterator>

// ... parser kod ... //

int main()
{
  std::string input(std::istream_iterator<std::string::value_type>(std::cin),
                         std::istream_iterator<std::string::value_type>());
					
  Parser parser(input);
  
  std::cout << std::boolalpha;

  std::cout << parser.axiom1() << "\n";
  std::cout << parser.axiom2() << "\n";
  std::cout << parser.axiom3() << "\n";
  
  return 0;
}

Ispišeš ulaz i lupiš Ctrl + Z i dobiješ rezultat.