How to... C++

[ivan90BG]

@MG-RAY, popravljeno.

@Geo, jes može, ali onda korisnik ove klase mora da zna da mora da uradi još nešto osim golog poziva operatora da bi koristio objekat pravilno (mora još jednom da indeksira). Operator () je zaokružen interfejs.

[Geomaster]

ivan90BG kaže:

@Geo, jes može, ali onda korisnik ove klase mora da zna da mora da uradi još nešto osim golog poziva operatora da bi koristio objekat pravilno (mora još jednom da indeksira). Operator () je zaokružen interfejs.

Ne shvatam, šta bi još trebao da zna? I običnoj matrici se pristupa s dva indeksa...

[Belphegor]

@Ivan90BG

...
Mat2D(int height, int width)
{
    this.width = width;
    this.height = height;
    this.data = new T[width*height];
}
...

Tako mozda mozes sa C#-om a u C++-u this je pokazivac, sintaksa za dereferenciranje ide ovako:

(*this).width; 
//ili
this->width

template < typename T >
class Array2D
{
    std::size_t rows, columns;
    T** data;
public:
    Array2D(std::size_t r, std::size_t c)
        : rows(r), columns(c)
    {
        data = new T*[rows];
        for(std::size_t i = 0; i < rows; ++i)
            data[i] = new T[columns];
    }
    ~Array2D()
    {
        for(std::size_t i = 0; i < rows; ++i)
            delete [] data[i];
        delete [] data;
    }
    T& operator () (std::size_t r, std::size_t c) const
    {
        return data[r][c];
    }
};

[ivan90BG]

Šta ću kad mi je mozak na sve strane (učenje, seminarski, projekat), i kad Qt Creator automatski menja tačku u sterlicu ako se otkuca posle pointera. (i onda ja onako lenjo C#-ovski samo lupam tačke )

[Ivan-94]

Pokusavam da uradim najednostavniju multithreaded aplikaciju:

#include <iostream>
#include <thread>
#include <chrono>

using namespace std;

void f()
{
	while(1)
	{
		cout << "From SIDE thread." << endl;
		this_thread::sleep_for(chrono::seconds(2));
	}
}

int main(int argc, _TCHAR* argv[])
{
	thread t1(f);
	t1.join();

	while(1)
	{
		cout << "From MAIN thread." << endl;
		this_thread::sleep_for(chrono::seconds(2));
	}
	return 0;
}

Ali izgleda da se scope prebaci u tu f-ju i ne vrati se u main, i dalje izvrsavajuci tu f-ju, kao bi ja hteo.

Tj. hocu da output bude, malo iz jedne f-je malo iz main.

Sta radim pogresno?

[EclipsE]

t1.join();

Čekaš da se thread t1 završi, što se nikad neće desiti.

[Ivan-94]

Ok ali kako da ne cekam da se zavrsi, nego da odmah posle pokretanja nastavi?

[Geomaster]

Pa nemoj da pozivaš join() na tom objektu

[Ivan-94]

Joj, cek, mozda nisam lepo formulisao pitanje.
Kako da pokrenem dve f-je odjednom i da jedna malo dobije vreme procesora malo druga?

[Geomaster]

Ivan-94 kaže:

Joj, cek, mozda nisam lepo formulisao pitanje.
Kako da pokrenem dve f-je odjednom i da jedna malo dobije vreme procesora malo druga?

Pa rekoh ti. Napravi novi thread i nemoj da joinuješ s njim i on će raditi uporedo. To je definicija threadova.

#include <iostream> 
#include <thread> 
#include <chrono> 
 
using namespace std; 
 
void f() 
{ 
    while(1) 
    { 
        cout << "From SIDE thread." << endl; 
        this_thread::sleep_for(chrono::seconds(2)); 
    } 
} 
 
int main(int argc, char* argv[]) 
{ 
    thread t1(f); 
 
    { 
        cout << "From MAIN thread." << endl; 
        this_thread::sleep_for(chrono::seconds(1)); 
    } 
    return 0; 
}

[Belphegor]

@Ivan-94
Zanimljiv link.

[voodoo_]

Ladno postoji std::thread, a ja seljak koristim pthread-ove još uvek

[Ivan-94]

Doslo uz C++11.

[Sheldon Cooper]

Kako da uzimam random number ( 0-100 ) odredjen broj puta ( verovatno for ciklus ) i da izvucem kojih se, recimo, 5 brojeva najvise puta izvlacilo i ispisem ih na ekranu? Ne treba mi cist kod, nego neka ideja kako bi to izgledalo.

[RaKuN_s_NeOnKoM]

Sheldon Cooper kaže:

Kako da uzimam random number ( 0-100 ) odredjen broj puta ( verovatno for ciklus ) i da izvucem kojih se, recimo, 5 brojeva najvise puta izvlacilo i ispisem ih na ekranu? Ne treba mi cist kod, nego neka ideja kako bi to izgledalo.

Evo ideja. Radis upravo to sto si napisao [random u petlji] a pratis tako sto napravis niz[101] (101 iz prakticnih razloga) i radis niz[random_izvuceni_broj]++
E sad trenutno nemam ideju kako da ispises bas 5 koji su se najvise pojavili ali imaces uvid koliko se puta koji broj pojavio pa smisli nesto.

Moglo bi i da imas niz struktura koje sadrze { broj, brojac } pa bi kasnije samo sortirao i ispisao 5 sa najvecim brojacem, ali ova prva ideja mi je zanimljivija samo je treba doraditi ako je moguce.

[ivan90BG]

void main()
{
    int niz[101];
    memset(niz, 0, 101*sizeof(int));
    srand(time(NULL));
    for (int i = 0; i < 40000; i++)
    {
        niz[rand() % 100]++;
    }

    TopLista lista(5);
    for (int i = 0; i <= 100; i++)
    {
        lista.probajDaDodaš(i, niz[i]);
    }

    for (int i = 1; i <= 5; i++)
    {
        printf("%d: %d se pojavio %d puta\n", i, lista.ključPozicije(i), lista.vrednostPozicije(i));
    }
}

Klasu TopLista ostavljam tebi da napišeš. Ako baš ne može viči. Hint: pri svakom ubacivanju će se lista možda menjati, a možda i neće.

[Belphegor]

@ivan90BG

void main()
...

void main is evil!

C++ resenje, valjda nisam prevideo nesto:

Spoiler za spoiler:

#include <iostream>
#include <iterator>
#include <limits>
#include <random>
#include <ctime>
#include <algorithm>
#include <functional>

class random
{
private:
    static std::mt19937 mt;
    random() {}
    random(const random& o) {}

public:

    template< typename TNum >
    static typename std::enable_if< std::is_floating_point<TNum>::value, TNum >::type
    get(TNum nmin = std::numeric_limits< TNum >::min(), TNum nmax = std::numeric_limits< TNum >::max())
    {
        std::uniform_real_distribution<TNum> treal(nmin, nmax);
        return treal(mt);
    }

    template< typename TNum >
    static typename std::enable_if< std::is_integral<TNum>::value, TNum >::type
    get(TNum nmin = std::numeric_limits< TNum >::min(), TNum nmax = std::numeric_limits< TNum >::max())
    {
        std::uniform_int_distribution<TNum> tint(nmin, nmax);
        return tint(mt);
    }
};

std::mt19937 random::mt = std::mt19937(static_cast<unsigned int>(std::time(nullptr)));

// N - ukupno izvucenih brojeva
// F - prvih n brojeva koji se ponavljaju
template < std::size_t N, std::size_t F >
class TopLista
{
private:

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

public:
    TopLista()
    {
        static_assert(N > F, "ERROR!");

        numbers.resize(N);

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

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

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

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

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

        std::find_if(std::begin(numbers), end, [](const tpnum& e){
            static std::size_t i = 0;
            std::cout << "Broj " << e.second << " se ponavlja " << e.first << " puta." << std::endl;
            return ++i >= F;
        });
    }

};

int main()
{
    TopLista<60, 5> tl;
    return 0;
}

[Geomaster]

STL je bio lep sve dok se nisu pojavile zle konstrukcije kao ove što je Belphegor koristio.

[ivan90BG]

@Belphagor, ako bi mogao malo da objasniš kako radi ovo tvoje sokoćalo. Gde vodiš koliko se svaki broj od 0 do 100 pojavio.

Elem, ja sam do sada debagovao i modifikovao implementaciju TopListe (one koja se uklapa u moj gornji kod), dok mi nije maločas puklo pred očima, i evo:

#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <string.h>

struct Par
{
    int key;
    int value;
};

int uporedi(const void* l, const void* r)
{
    return -(((Par*)l)->value - ((Par*)r)->value);
}

int main()
{
    Par niz[101];
    memset(niz, 0, sizeof(niz));

    for (int i = 0; i < 101; ++i)
        niz[i].key = i;

    srand(time(NULL));
    for (int i = 0; i < 40000; i++)
    {
        niz[rand() % 101].value++;
    }

    qsort(niz, 101, sizeof(Par), uporedi);

    for (int i = 0; i < 101; ++i)
    {
        printf("%d: (%d, %d)\n", i, niz[i].key, niz[i].value);
    }
    return 0;
}

Jbg, C++ megalomanija se ne isplati.

[M.Silenus]

Hi, folks! Vau, ova top lista je stvarno nešto popularna. Pa, evo i mog rešenja Napomena: ovo rešenje nije najefikasnije, mrzelo me da izvlačim top 5, pa umesto toga vršim sortiranje. Takođe, pošto koristim dosta stvari iz C++11 biblioteke, ovo mu dođe kao demonstracija korišćenja tih... stvari...

Evo rešenja:

#include <iostream>
#include <random>
#include <chrono>
#include <vector>
#include <algorithm>
#include <numeric>
#include <functional>

int main()
{
  auto now = std::chrono::high_resolution_clock::now();
  auto seed = std::chrono::duration_cast<std::chrono::nanoseconds>
    (now.time_since_epoch()).count();

  // test uniformne raspodele
  {
    std::cout << "Uniformna raspodela (izvucen broj:broj izvlacenja):\n";

    // svaki broj ima istu verovatnocu pojavljivanja
    std::uniform_int_distribution<> u_dist(0,100); 
    std::mt19937 mt1(seed);
    auto u_rand = std::bind(u_dist, mt1);

    std::vector<int> counts(101, 0);
    std::vector<size_t> indices(101);
    std::iota(begin(indices), end(indices), 0);
    
    for(size_t i = 0; i != 10000; ++i){
      ++ counts[u_rand()];
    }

    std::sort(begin(indices), end(indices),
	      [&counts](size_t a, size_t b) -> bool {
		return counts[a] >= counts[b];
	      });

    for(size_t i = 0; i != 5; ++ i)
      std::cout << indices[i] << "\t" << counts[indices[i]] << "\n";
  }
  std::cout << "\n";
  // test binomne raspodele
  {
    double p = 0.3;
    std::cout << "Binomna raspodela, p = " 
	      << p 
	      << " (izvucen broj:broj izvlacenja):\n";

    // vrsi se 100 eksperimenata, svaki ima verovatnocu uspeha 'p'; vraca broj uspelih
    std::binomial_distribution<> b_dist(100, 0.5); 
    std::mt19937 mt2(seed);
    auto b_rand = std::bind(b_dist, mt2);

    std::vector<int> counts(101, 0);
    std::vector<size_t> indices(101);
    std::iota(begin(indices), end(indices), 0);
    
    for(size_t i = 0; i != 10000; ++i){
      ++ counts[b_rand()];
    }

    // puca sa obicnim sort-om iz nekog razloga
    // mozda zato sto je vecina elemenata 0?
    std::stable_sort(begin(indices), end(indices),
	      [&counts](size_t a, size_t b) -> bool {
		return counts[a] >= counts[b];
	      });

    for(size_t i = 0; i != 5; ++ i)
      std::cout << indices[i] << "\t" << counts[indices[i]] << "\n";
  }

  return 0;
}

PS: A da počnemo da koristimo Pastebin za ove stvari?