recent am instalat jocul grand theft auto: san andreas si la a2- a misiune (ma refer la misiunea ryder), personajul ryder te duce la o frizerie pentru a iti face parul, nimic neobisnuit pana...? (mai mult)
recent am instalat jocul grand theft auto: san andreas si la a2-a misiune (ma refer la misiunea ryder), personajul ryder te duce la o frizerie pentru a iti face parul, nimic neobisnuit pana acum nu? pai dupa ce a terminat frizerul sa iti faca parul trebuie sa apesi pe tasta "return" de pe tastatura pentru a putea iesi din meniu, dar eu nu gasesc nici unde pe tastatura tasta "return", e cumva o comanda pe tastatura? sau e o tasta obisnuita pe care eu nu o am? (cred ca ar trebui sa fie de mentionat ca ma jucam grand theft auto: san andreas de pe laptop).
cand iti faci parul trebuie sa apesi space ca sa selectezi ce frizura vrei si enter cand dai cancel/back. iar return este de obicei tasta esc (escape) sau poti dupa ce ai selectat frizura sa apesi de multe ori enter.
Probabil că ar trebui să înceapă cu un pic de teorie si exemple simple, cum ar fi [mijloc de deplasare algoritmul](http://www.gameprogrammer.com/fractal.html). Ar trebui, de asemenea, să învețe un pic despre [Zgomot Perlin](https://en.wikipedia.org/wiki/Perlin_noise) dacă sunteți interesat în generarea de grafice. Am folosit asta ca să încep cu ultimul meu an de proiect pe generarea de procedură.


[Fractali](https://en.wikipedia.org/wiki/Fractal) sunt strâns legate de generarea de procedură.


[Terragen](https://en.wikipedia.org/wiki/Terragen) și [SpeedTree](https://en.wikipedia.org/wiki/SpeedTree) vă va arăta unele posibilități uimitoare de procedură generație.


Generarea de procedură este o tehnică ce poate fi folosită în orice limbă (acesta este cu siguranta nu se limitează la limbaje procedurale, cum ar fi C, deoarece poate fi folosit în OO limbi, cum ar fi Java, și Logica limbi, cum ar fi Prolog). O bună înțelegere a recursivitate în orice limbă va consolida înțelegerea dumneavoastră de Generație de Procedură.


Ca și pentru 'grav' sau non-joc de codul de procedură generație de tehnici au fost utilizate pentru:


* simula creșterea orașelor, în scopul de a planului de management al traficului
* pentru a simula creșterea vaselor de sânge
* SpeedTree este folosit în filme și arhitectural prezentări Cea mai potrivita masina pentru un incepator este masina instructorului :))  

  

In Europa suntem obisnuiti cu cutiile manuale, abia de cativa ani au inceput sa ne invadeze si cele automate. In SUA, in schimb, un procent destul de mic de soferi stiu sa foloseasca masini cu cutii manuale. La urma urmei depinde ce masina urmeaza sa ai.   

  

Benzina sau motorina nu conteaza in aceasta problema.  

  

Totusi, pentru un incepator sunt lucruri mult mai importante pe care trebuie sa le acumuleze: reflexe, comenzi, reguli, semne si de ce nu respect, responsabilitate.  

  

Sa nu uitam ca o masina poate ucide, atat pe cel care o conduce cat si pe altii. Prefera incepatorii ... poate o fi vreo eroare de la ei,de sistem sau de la tine de la pc(net)...si eu mai fac pauze cate 2-3 zile maxim da reiau de unde am ramas,eu de cand am inceput nu am avut niciodata probleme,nici macar o mica eroare,is logat si pe laptop si telefon si vreau sa zic ca pe laptop chiar nu am mai intrat de foarte mult timp si tot am luato de unde am ramas........acum nu stiu ce altceva sa ti zic,poate sa le dai un mesaj lor(moderatorilor programului astuia,sa vezi ce sa intamplat)in rest iti doresc succes....bye Folosesc adesea metoda descrisă [în răspunsul
mech](https://cooking.stackexchange.com/a/90913/65929) - folosirea mănușilor de calitate la manipularea mâncării
crude. Atât la serviciu, cât și la domiciliu.


O opțiune secundară pe care o folosesc adesea este curățarea
globală a robinetelor. Pur și simplu, luați acele robinete cu
mâinile primei carne cu impunitate. Dă-ți mâinile o clătire rapidă,
apoi spală-le cu săpun și frecat în plus. Apoi curățați robinetele.
Apoi clătiți totul din nou.


Există, de asemenea robinete care pot fi manipulate cu coatele
și am auzit de robinete sensibile la căldură care răspund la
atingere, de asemenea.


Amintiți-vă că carnea crudă nu vă poate face rău dacă tocmai ați
curățat ulterior. Aceasta ar putea include robinetele pe care
le-ați folosit la curățare. salut.dupa anunt cred ca esti un sau o lenes/a.poate gasesti o agentie sa-ti ia un comision atat de mare incat sa te arda buzunarul,asa va trebuie voua astora care nu sunteti in stare sa vindeti ceva singuri. Răspuns scurt:



```
$ ssh-keygen -p
```

Acest lucru vă va solicita să introduceți keyfile relaxare, frază veche și nouă frază de acces (care poate fi lăsat necompletat pentru a avea nici o frază de acces).


Dacă doriți să facă totul pe o singură linie fără solicitări face:



```
$ ssh-keygen -p [-P old_passphrase] [-N new_passphrase] [-f keyfile]
```

**Important:** Feriți-vă că, atunci când execută comenzi vor fi de obicei înregistrate în ta `~/.bash_history` de fișier (sau similare) în text simplu, inclusiv toate argumentele oferite (adică passphrases în acest caz). Este, prin urmare, este recomandat să folosiți prima opțiune dacă nu aveți un motiv special pentru a face altfel. Observați totuși că puteți utiliza în continuare `-f fisier-cheie fără a fi nevoie să specificați`-P " sau " - N`, și că keyfile implicit`~/.ssh/id\_rsa, astfel încât, în multe cazuri, aceasta's a nu mai avea nevoie.


S-ar putea dori să ia în considerare folosind ssh-agent, care poate cache fraza de acces pentru un timp. Cele mai recente versiuni ale gpg-agent sprijini, de asemenea, protocolul care este utilizat de către ssh-agent. **UPDATE**


Acest răspuns este destul de vechi, și așa descrie ceea ce a fost 'bine' la momentul respectiv, care a fost inteligent indicii furnizate de Impuls bibliotecă. Deoarece C++11, biblioteca standard a furnizat suficiente smart pointeri de tipuri, și așa ar trebui să favorizeze utilizarea [`std::unique_ptr`](http://en.cppreference.com/w/cpp/memory/unique_ptr), [`std::shared_ptr`](http://en.cppreference.com/w/cpp/memory/shared_ptr) și [`std::weak_ptr`](http://en.cppreference.com/w/cpp/memory/weak_ptr). 


Acolo a fost, de asemenea, [`std::auto_ptr`](http://en.cppreference.com/w/cpp/memory/auto_ptr). A fost foarte mult ca o luneta pointer, cu excepția faptului că a avut, de asemenea, "speciale" periculoase capacitatea de a fi copiate — care, de asemenea, în mod neașteptat transferă dreptul de proprietate.
**S-a depreciat în C++11 și eliminate în C++17**, deci nu ar trebui't-l folosească.



```
std::auto_ptr<MyObject> p1 (new MyObject());
std::auto_ptr<MyObject> p2 = p1; // Copy and transfer ownership. 
                                 // p1 gets set to empty!
p2->DoSomething(); // Works.
p1->DoSomething(); // Oh oh. Hopefully raises some NULL pointer exception.
```






**RĂSPUNS VECHI**


Un smart pointer este o clasa care se infasoara un 'prime' (sau 'gol') C++ pointer, pentru a gestiona durata de viață a obiectului de a fi subliniat. Nu există nici un singur inteligente de tip pointer, dar toate dintre ele încerca să rezumat o primă pointer într-un mod practic.


Smart pointeri ar trebui să fie de preferat peste prime indicii. Dacă simțiți că aveți nevoie pentru a utiliza pointeri (ia în considerare mai întâi dacă într-adevăr ** face), ar fi normal să doriți să utilizați un smart pointer deoarece acest lucru poate atenua multe dintre problemele cu prime indicii, în principal, uitând să ștergeți obiectul și scurgeri de memorie.


Cu prime indicii, programatorul trebuie să specifice în mod explicit distruge obiectul atunci când acesta nu mai este util.



```
// Need to create the object to achieve some goal
MyObject* ptr = new MyObject(); 
ptr->DoSomething(); // Use the object in some way
delete ptr; // Destroy the object. Done with it.
// Wait, what if DoSomething() raises an exception...?
```

Un smart pointer prin comparație definește o politică ca atunci când obiectul este distrus. Tu încă mai au pentru a crea un obiect, dar nu mai trebuie să vă faceți griji despre distrugerea ei.



```
SomeSmartPtr<MyObject> ptr(new MyObject());
ptr->DoSomething(); // Use the object in some way.

// Destruction of the object happens, depending 
// on the policy the smart pointer class uses.

// Destruction would happen even if DoSomething() 
// raises an exception
```

Cea mai simplă politica de utilizare implică domeniul de aplicare de smart pointer obiect înveliș, cum ar fi puse în aplicare până la [`boost::scoped_ptr`](https://www.boost.org/doc/libs/release/libs/smart_ptr/scoped_ptr.htm) sau [`std::unique_ptr`](http://en.cppreference.com/w/cpp/memory/unique_ptr). 



```
void f()
{
    {
       std::unique_ptr<MyObject> ptr(new MyObject());
       ptr->DoSomethingUseful();
    } // ptr goes out of scope -- 
      // the MyObject is automatically destroyed.

    // ptr->Oops(); // Compile error: "ptr" not defined
                    // since it is no longer in scope.
}
```

Notă: std::unique\_ptr` cazuri nu pot fi copiate. Acest lucru previne pointer de a fi șterse de mai multe ori (în mod incorect). Cu toate acestea, puteți trece referiri la aceasta în jurul valorii de la alte funcții-ai sunat.


`std::unique\_ptr sunt utile atunci când doriți pentru a lega de viata a obiectului la un anumit bloc de cod, sau dacă încorporat ca date membre în interiorul altui obiect, durata de viata de care alt obiect. Obiectul există până conțin bloc de cod este ieșit, sau până la obiect este distrus.


Mai complex smart pointer politică implică numărare de referință indicatorul. Acest lucru permite ca indicatorul să fie copiate. Când ultima "de referință" la obiectul este distrus, obiectul este șters. Această politică este implementată de [`boost::shared_ptr`](https://www.boost.org/doc/libs/release/libs/smart_ptr/shared_ptr.htm) și [`std::shared_ptr`](http://en.cppreference.com/w/cpp/memory/shared_ptr).



```
void f()
{
    typedef std::shared_ptr<MyObject> MyObjectPtr; // nice short alias
    MyObjectPtr p1; // Empty

    {
        MyObjectPtr p2(new MyObject());
        // There is now one "reference" to the created object
        p1 = p2; // Copy the pointer.
        // There are now two references to the object.
    } // p2 is destroyed, leaving one reference to the object.
} // p1 is destroyed, leaving a reference count of zero. 
  // The object is deleted.
```

Referință numărat indicii sunt foarte utile atunci când durata de viață a obiectului este mult mai complicat, și nu este legat direct la o anumită secțiune de cod sau de la un alt obiect.


Există un dezavantaj de referință numărat pointer — posibilitatea de a crea o marionetă de referință:



```
// Create the smart pointer on the heap
MyObjectPtr* pp = new MyObjectPtr(new MyObject())
// Hmm, we forgot to destroy the smart pointer,
// because of that, the object is never destroyed!
```

O altă posibilitate este crearea de referințe circulare:



```
struct Owner {
   std::shared_ptr<Owner> other;
};

std::shared_ptr<Owner> p1 (new Owner());
std::shared_ptr<Owner> p2 (new Owner());
p1->other = p2; // p1 references p2
p2->other = p1; // p2 references p1

// Oops, the reference count of of p1 and p2 never goes to zero!
// The objects are never destroyed!
```

Pentru a rezolva această problemă, atât Stimula și C++11 au definit o `weak_ptr` pentru a defini un slab (nenumărate) de referință la un `shared_ptr`. Ați putea vedea această eroare într-un instrument de depanare a
unui client.


De exemplu, [Fiddler](https://www.fiddler2.com/) vă va arăta răspunsul care a revenit de la
server - și puteți utiliza fila WebFiew a Fiddler consultați
răspunsul HTML. Răspunsul HTML în acest caz vă va arăta ecranul de
eroare galben ASP.NET.


În plus față de fișierul Fiddler, puteți utiliza, de asemenea,
instrumente de depanare a browserului care se integrează în IE ,
Chrome sau Opera sau puteți descărca [Firebug](https://getfirebug.com/) pentru FireFox.
Fiecare instrument are o filă de rețea care vă va arăta toate
solicitările ajax și răspunsurile acestora. Evident ca gresesti.Obtii ceva de genul kg2 etc. Buna , poti detalia ? ai terminat cuvinte de baza 1 si nu poti trece la cuvinte de baza 2 ?
Ori In cazul in care Ai terminat tot ''arborele'',Ai in dreapta Consolideaza cunostiintele si poti trece la alt nivel .