How to... C++

[NISAM NESTO SMART]

Hmm da.....
Pošto su očito veliki eksperti na ovom forumu dali dijagnozu da je kreator C++ mentalno nestabilan(ili je možda čovek glup pa nije znao bolje) i zato je i upropastio jezik, koji očigledno samo idioti koriste koji ne znaju za bolje.

Pošto ima dosta takvih idiota na forumu nek bude ova tema sticky(a nek moderator izbrise ove nebitne postove)...

[ivan90BG]

Ne, ne, nisam rekao da je Bjarn poremećen sam po sebi, nego da neka sila (koju sam nazvao gremlin) konstantno sabotira sve pokušaje pravljenja dobrog skupa jezik-bilblioteka-runtime. ODkud ja znam šta je po sredi, možda bad luck. Ja mislim da je C# odličan jezik, .NET biblioteka je super, coding standardi koje nameće dobri, ali virtuelna mašina...; isto i sa Javom.

Znači pun pogodak bi bio jezik kao C# sa mogućnostima C-a, nativno kompajliran, sa velikom bibliotekom kao što su .NET i Java standardna, i da mu ne trebaju header fajlovi, odnosno da se sveinformacije sadrže u binarnim fajlovima, kao što je to kod .NET assembly-a ili Java fajlova.

[Belphegor]

....NET biblioteka je super, coding...
...sa velikom bibliotekom kao što su .NET i Java standardna

Vidi se da se dosta oslanjas na te biblioteke koje su ti servirane na tacni i ne bi mogao bez njih da se snadjes. Sa C++-som mozes sam da pravis te pomocne biblioteke, organizujes stvari kako tebi odgovaraju, a ako naidjes na neku "prepreku" kao sto je ono sa enum konstantama uvek mozes sam da napravis da se ponasa tako kako ti zelis a ne da kmecis kako to fali jeziku a u stvari i ne treba da bude deo jezika. A to sto spominjete C nije vam od neke pomoci, jer se vidi i da se tu ne snalazite.
Ajd' onda neka neko od vas napravi split string funkciju u C-u i pomogne Ivanu umesto da bez veze trolujete ovu temu.
Ako vam se ne svidja C++ ne morate da ga koristite!

...i da mu ne trebaju header fajlovi...

Sa ovim su obicno pocetnici isfrustrirani kad naprave vise od jednog izvornog fajla i ne mogu da povezu 2 klase koje zavise jedna od druge pa za to krive jezik.

Circular dependency.

Takođe pustite niz WC šolju donje crte i mala slova...

Joj, koliko je ovo pateticno.
Ako ne umes da ga procitas "nadeni" mu drugo ime:

typedef glupavo_ime superCoolIme;

[voodoo_]

Belphegor kaže:

A to sto spominjete C nije vam od neke pomoci, jer se vidi i da se tu ne snalazite.

Koji mi? Ja C razbijam, fala na pitanju.

[Belphegor]

Ja C razbijam, fala na pitanju.

Your kung-fu is the best.

[Geomaster]

voodoo_ kaže:

Ja C razbijam, fala na pitanju.

[Kosinus]

@Ivan-94:

char** explode( const char delim, char* src )
{
    char * start = src;
    char * ptr = src;
    char ** tab;
    int i = 0, pos = 0, len = 0;
    int items = 0;

    while( *src ) 
    { 
        if( *src == delim ) 
            items++; 
        src++; 
    }

    if( !items )
        return NULL;

    items++;

    src = start;
    tab = new char * [items];

    while( *ptr && i < items )
    {
        if( *src == delim || *src == 0 )
        {
            len = 0;
            ptr = start;

            while( ptr < src )
            {
                len++; 
                ptr++;
            }

            tab[ i ] = new char [len + 1];
            pos = 0;

            while( start < ptr )
            { 
                tab[ i ][pos] = *start; 
                start++; 
                pos++; 
            }

            tab[ i ][pos] = 0;
            start = ptr + 1;
            i++;
        }

        src++;
    }

    tab[ i ]= NULL;

    return tab; 
}

Funkcija nije moje delo - nasao sam je negde na internetu pre koju godinu.

Koristis ovako:

char ** Bla = explode( ':', "1.1.1.1:28960" );

Bla[ 0 ] // Pokazivac na prvi niz karaktera
Bla[ 1 ] // Pokazivac na drugi niz
// Itd...

Mala funkcija koju sam napravio da ti pomogne da izbrojis na koliko delova je tekst podeljen:

int count( char ** tabsrc )
{
    int i = 0;
    while( tabsrc[ i ] != NULL )
        i++;

    return i;
}

Ne zaboravi da posle koriscenja oslobodis memoriju:

int c = count( Bla );

for( int i = 0; i < c; i++ )
    delete [ ] Bla[ i ];

delete [ ] Bla;

[Belphegor]

More C++

#include <iostream>
#include <string>
#include <regex>
#include <iterator>
#include <limits>

int main()
{
    std::string str   = ".HEHE:.HOHO.HIHI,HAHA,.:";
    std::string delim = ":.,";
    std::regex pattern("[^" + delim + "]+");
    std::vector<std::string> result;

    const std::sregex_token_iterator end;
    std::sregex_token_iterator i(str.begin(), str.end(), pattern);
    for(; i != end; ++i)
    {
        result.push_back(*i);
    }

    std::ostream_iterator<std::string> out(std::cout, "\n");
    std::copy(result.begin(), result.end(), out);

    std::cout << "Press enter to exit..." << std::endl;
    std::cin.ignore( std::numeric_limits< std::streamsize >::max(), '\n' );
    return 0;
}

out:

HEHE
HOHO
HIHI
HAHA

[EclipsE]

Mislis regex

[Luigi]

Dali bi mi neko znao reći is kog razloga kada random funkciju inicijaizujem na sledeći način uvek dobijam istu listu nasumičnih brojeva?

srand (NULL);

ako probam proslediti time funkciju kao parametar program ko da je u beskonačnoj petlji:

srand ( time(NULL) );

[EclipsE]

Zato što "random" nije stvarno random... Zavisno od implementacije random funkcija može da varira, ali se uglavnom implementira kao:
(note: brojevi su ovde samo proizvoljni)

unsigned seed = 0;

unsigned rand()
{
    seed = seed * 123456789 + 12345;
    return (seed / 12345) % 54321;
}

A srand:

void srand(unsigned s)
{
    seed = s;
}

Kao što možeš da vidiš iz rand funkcije, svaki sledeći broj zavisi od prethodnog seed-a. Ako ne pozoveš srand sa nekom unikatnom vrednošću, dobićeš uvek istu sekvencu brojeva. Ako pozoveš srand(0), opet ćeš dobiti istu sekvencu random brojeva, jer se uvek računaju iste vrednosti.

Razlog zašto time(0) daje uvek drugačije vrednosti je zato što se time menja svake sekunde, tako da u svakoj sekundi imaš drugačiju sekvencu random brojeva.

Razlog zašto se tebi program vrti beskonačno je jer uvek pozivaš srand( time(0) )! Obzirom da je izvršenje programa veoma brzo (milijarde operacija po sekundi), tebi se seed uvek postavlja na istu vrednost, pa rand() računa istu vrednost u toku jedne sekunde.

TLDR: pozovi samo jednom srand( time(0) ) na početku programa i uživaj.

[Luigi]

Tako i radim, pozovem samo jednom... Zanimljivo je da kad uradim ovaj test kod:

#include<iostream>
#include <stdlib.h>
#include <time.h>
using namespace std;
int indexi [9][9];
//------------------------------------------------------------
//funkcija koja vraca  random broj u intervalu 0 - 8
//------------------------------------------------------------
int randomBroj()
{
    int random = rand() %9;
	return random;
}
//------------------------------------------------------------
void popunaKombinacija()
{
	int k=0,x,y;
	for(int a=0;a<9;a++)
	{
		for(int b=0;b<9;b++)
		{
			indexi[a][b]=0;
		}
	}
	while(k<81)
	{
		x=randomBroj(); //funkcija koja vraca 
		y=randomBroj(); //nasumicni broj u intervalu 0-8
		if(indexi[x][y]==0)
		{
			indexi[x][y]=k+1;
			k++;
		}
    }
}
//---------------------------------------------------------------
int main()
{
	srand( time(0) );
	popunaKombinacija();
	for(int i=0;i<9;i++)
	{
		cout<<" "<<endl;
		if(i%3==0)
			cout<<" "<<endl;
		for(int j=0;j<9;j++)
		{
			if(j%3==0)
				cout<<" ";
			if(indexi[i][j]==0)
				cout<<". ";
			else if(indexi[i][j]<10)
			{
				cout<<0;
				cout<<indexi[i][j];
				cout<<" ";
			}
			else
			{
				cout<<indexi[i][j];
				cout<<" ";
			}
		}
	}
	getchar();
	getchar();
}

radi bez problema. Istu inicijalizaciju i obe funkcije koristim u većem programu gde se najpre dešava upravo ono što u test kodu, tamo ne radi skuca se i samo vrti.

[EclipsE]

Onda nije problem u random brojevima, već u tom drugom kodu...

[Belphegor]

Ne razumem zasto nasumicno biras indexe niza kad bi isto dobio i ovako:

#include <iostream>
#include <algorithm>
#include <ctime>
#include <iterator>

int main()
{
    srand((unsigned int)time(0));
    int indexi[9][9];
    int i = 0;
    std::for_each(&indexi[0][0], &indexi[0][0] + 81, [&i](int& inx) { inx = ++i; });
    std::random_shuffle(&indexi[0][0], &indexi[0][0] + 81, [](const int& num){ return rand() % num; });

    std::ostream_iterator<int> out(std::cout, "\n");
    std::copy(&indexi[0][0], &indexi[0][0] + 81, out);

    std::cin.get();
    return 0;
}

Evo ti i "duze" verzije ako ti kompajler ne podrzava lambada funkcije:

#include <iostream>
#include <algorithm>
#include <ctime>
#include <iterator>

int moj_random(const int& num)
{ 
    return rand() % num; 
}

int main()
{
    srand((unsigned int)time(0));
    int indexi[9][9];
    int k = 0;
    for(int i = 0; i < 9; ++i)
    {
        for(int j = 0; j < 9; ++j)
        {
            indexi[i][j] = ++k;// 1-82
        }
    }

    std::random_shuffle(&indexi[0][0], &indexi[0][0] + 81, moj_random);

    for(int i = 0; i < 9; ++i)
    {
        for(int j = 0; j < 9; ++j)
        {
            std::cout << indexi[i][j] << std::endl;
        }
    }

    

    std::cin.get();
    return 0;
}

[Andross]

Da li std::list brise sve elemente iz liste ako obrisem instancu neke klase koja sadrzi listu, i.e. da li u destruktoru klase treba da pozivam mojaLista.clear() ili ne? (jbg navikao sam na garbage collector u c# )

[M.Silenus]

Ne, u destruktoru klase ne moraš da zoveš clear() metod. Destruktor liste uništava sve elemente liste.

Napomena, ako su elementi liste pokazivači, onda moraš ručno da obrišeš objekte na koje ti pokazivači, je li, pokazuju (videti primer):

std::list<int*> ints;

ints.push_back(new int);
ints.push_back(new int);
ints.push_back(new int);

// brisanje
for(auto iter = begin(ints); iter != end(ints); ++ iter)
  delete *iter;

// a evo i fensi načina ;)
std::for_each(begin(ints), end(ints), [](int* pi) { delete pi; });

Napomena, ovo je C++11.

Ako hoćeš da automatizuješ ovo malo, možeš da koristiš pametne pokazivače:

std::list<std::shared_ptr<int>> ints;

ints.push_back(std::make_shared<int>());
ints.push_back(std::make_shared<int>());
ints.push_back(std::make_shared<int>());

Ne moraš ništa da brišeš, shared_ptr brine o tome.

[Belphegor]

Zavisi sta ti je u listi.
Ako drzi pokazivace na objekte kreirane na heap-u onda moras rucno da brises pre nego ubijes tu klasu

class Foo
{
private:
    std::list<Bar*> lb;
...
};

Foo::~Foo()
{
     const auto& end = lb.end();
    auto it = lb.begin();
    for(; it != end; ++it)
    {
        Bar* p = *it;
        delete p;
        p = nullptr;
    }
}

ili jednostavno:

#include <memory>
typedef std::shared_ptr<Bar> sp_bar;
...
class Foo
{
private:
    std::list<sp_bar> lb;
...
};

...
lb.push_back(sp_bar(new Bar(...));

i ne moras nista da mislis.

A evo ti i pomocna biblioteka za detektovanje curenja memorije.
http://www.windows7download.com/win7.../myvcnzgr.html

EDIT: Ninja M.Silenus

[Geomaster]

Upravo tako, samo da pojasnim, kad se std::list uništi (izađe van scope-a ili pomoću delete) on briše svoje elemente. To znači da ako lista sadrži pokazivače, pokazivači će biti uništeni, ali ne i objekti na koje oni pokazuju. U suštini, pravilo važi - o dealokaciji memorije brine onaj ko ju je alocirao. Ako si ti pozvao new kako bi alocirao neku memoriju, moraš pozvati i delete da tu istu memoriju dealociraš. Ostalo sve nije tvoja briga.

[Belphegor]

Lets get crazy.

Ako ces da brises rucno evo genericke funkcije, bazirano na M.Silenus for_each funkciji:

template< typename T >
typename std::enable_if< std::is_pointer< typename T::value_type >::value, void >::type
delete_container(T& c)
{
    std::for_each(std::begin(c), std::end(c), [] ( typename T::value_type v) { delete v; } );
}
...
std::list<int*> ints;
std::vector<Foo*> foos;
...
delete_container(ints);
delete_container(foos);

[Andross]

Da da, sad se secam. Sta cu proslo je 5 godina od kako sam zadnji put pipnuo C++, zaborave se neke stvari