buna tpu.
am un modem huawei smartax mt882 de la romtelecom.
la el este connectat un router d- link dir- 501.intrebarea mea:
este posibil ca modemu sa se fi transformat in router? pt ca la redirecte...? (mai mult)
buna tpu.
am un modem huawei smartax mt882 de la romtelecom.
la el este connectat un router d-link dir-501.intrebarea mea:
este posibil ca modemu sa se fi transformat in router? pt ca la redirecte nu mai fac dropuri deloc.
modem=router! daca vrei sa faci dropuri[redirectati], trebuie sa faci port forwarding!
uite ai aici un tutorial: http://www.inpc.ro/erori-clicknet-dialup/huawei/port-forward-mt882hg520s dar la ip adress trebuie sa pui ce ip ai tu de lan! start->control panel->network connections
aici dai dublu click pe local area conection si dai pe support si ai acolo "ip address" [acela e ipul de lan]
sper ca te-am ajutat, ca si mie mi-a mers. 
ps: firewall off [exceptii dezactivate]
cel mai probabil cpanel de mxhost nu functioneaza cum trebuie, nu face update si nu adauga mai departe datele in dns.

poti testa daca un domeniu e rezolvat de un anumit nameserver cu:

dig test.ionutstaicu.com @ns1.mxhost.ro

dig test.ionutstaicu.com @ns2.mxhost.ro

am mai patit sa fie ok pe un … Mersi pentru raspuns. Se pare că această problemă a avut de a face cu unele de corupție cu datele meta. Am ajuns să merg înapoi în Coloana Derivat Transformare, redenumit coloana din greșeală, apoi a adăugat o nouă coloană derivată cu numele vechi. Am salvat de transformare, iar apoi a eliminat coloana originală. Asta a rezolvat problema.


Vă mulțumim pentru răspunsurile. va multumim pentru interesul acordat sectiunii noastre de consultanta. situatia semnalata de dumneavoastra a fost directionata catre departamentul de suport tehnic si, pe parcursul acestei zile, veti fi contactata de catre colegii nostri. Mai puțin deasupra capului (fără SĂPUN plic să-și încheie fiecare apel in)


Mai puțin dublarea (HTTP deja reprezintă operațiuni, cum ar fi ȘTERGE, a PUS, pentru a PRIMI, etc. care au, de altfel, să fie reprezentate într-un SĂPUN plic).


Mai standardizate - HTTP operațiuni sunt bine înțelese și să opereze în mod constant. SĂPUN implementari pot obține delicat.


Mai lizibil și testabile (mai greu pentru a testa SĂPUN cu doar un browser).


Don't nevoie pentru a utiliza XML (ei bine, ai un fel de don't pentru SĂPUN, dar nu prea are sens din moment ce ai're deja face parsarea de plic).


Bibliotecile au făcut SĂPUN (un fel de) ușor. Dar sunt abstractizare departe o mulțime de concediere dedesubt, după cum am arătat. da, în teorie, SĂPUN poate trece peste alte transporturi astfel încât să se evite călare pe un strat de a face lucruri similare, dar în realitate doar despre toate SĂPUN munca'll face vreodată este de peste HTTP. [**Xiaomi Mi Band 3**](https://bit.ly/2tKB4Si) este cea mai buna bratara fitness

Pentru a imbina utilul cu placutul si a te bucura de monitorizarea unor parametri uzuali ai sanatatii tale, o bratara fitness precum aceasta, care se bucura si de un pret accesibil oricarui buzunar, iti poate aduce beneficii. Cel mai important dintre ele este faptul ca iti poti tine sub control ritmul cardiac, fiind mereu informat cu privire la pulsul tau gratie senzorului incorporat.

[**Huawei Band 2 Pro**](https://bit.ly/2EJTAkp)

Pentru un look elegant si modern, dar si un strop de tehnologie la incheietura mainii, modelul acesta de bratara fitness va face minuni. Datorita designului rafinat, ce incorporeaza micul calculator cu ecran tactil in bratara, se potriveste oricarui tip de tinuta, folosind materiale durabile in constructia sa, cu precadere otel inoxidabil si silicon.

[**Xiaomi Mi Band 2 + Folie De Protectie**](https://bit.ly/2Td2orC)

Optiunea aceasta accesibila mai tuturor doritorilor prezinta functiile de baza ale unei bratari pentru monitorizare zilnica, incluzand si un senzor de puls, pe care il vei folosi oricand doresti, insa care nu include citire continua a batailor inimii. JavaScript nu are suport pentru multi-threading pentru că JavaScript interpret în browser-ul este un singur fir (AFAIK). Chiar și Google Chrome nu va lăsa o singură pagină web JavaScript rulează în același timp, deoarece acest lucru ar provoca distrugeri masive de probleme de concurenta în paginile web existente. Toate Chrome nu este de a separa mai multe componente (diferite tab-uri, plugin-uri, etc.) în procese separate, dar nu-mi pot imagina o singură pagină având mai mult de un JavaScript fir.


Cu toate acestea, puteți utiliza, așa cum a fost sugerat, `setTimeout` pentru a permite un fel de programare și "fals" de concurenta. Acest lucru provoacă browser-ul pentru a recâștiga controlul de redare fir, și începe cod JavaScript furnizate `setTimeout după anumit număr de milisecunde. Acest lucru este foarte util dacă doriți pentru a permite viewport (ceea ce vezi) pentru a actualiza în timp ce efectuează operațiuni pe ea. Doar looping prin exemplu, coordonatele și actualizarea unui element în consecință, vă va face să vezi începutul și sfârșitul poziții, și nimic în între.


Vom folosi o abstracție în bibliotecă JavaScript, care ne permite de a crea procese și fire care sunt toate gestionate de către același JavaScript interpret. Acest lucru ne permite să executați acțiuni în felul următor:


* Un Proces, Firul 1
* Un Proces, Firul 2
* Procesul B, 1 Fir
* Procesul De O, Fir 3
* Un Proces, Thread 4
* Procesul B, Firul 2
* Pauză De Un Proces
* Procesul B, Fir 3
* Procesul B, Fire 4
* Procesul B, Fir 5
* Începe Un Proces
* Un Proces, Thread 5


Aceasta permite o formă de planificare și falsuri paralelism, pornirea și oprirea de fire, etc, dar nu va fi adevărat multi-threading. Nu cred că va fi vreodată puse în aplicare în limba în sine, deoarece adevarat multi-threading este utilă numai în cazul în care browser-ul poate rula o singură pagină, multi-threaded (sau chiar mai mult decât un singur nucleu), iar dificultățile sunt mult mai mari decât posibilitățile suplimentare.


Pentru viitorul JavaScript, check this out:
[https://developer.mozilla.org/presentations/xtech2006/javascript/](https://web.archive.org/web/20170920070053/https://developer.mozilla.org/presentations/xtech2006/javascript/) daca inchizi browserul sau dai shutdown acele evenimente vor fi emise. daca scoti din priza sau ramai fara curent nu vor mai fi emise. Nu, trebuie să fie capabil să citească din portul UDP folosit pentru a executa interogarea M-SEARCH din domeniul dvs. multicast. In nici un caz în ceea ce știu. Acest lucru s-ar putea schimba dacă Google decide să utilizeze un alt protocol de descoperire, în plus față de DIAL.


<http://www.dial-multiscreen.org/>


[Citirea din port udp în browser](https://stackoverflow.com/questions/17605252/reading-from-udp-port-in-browser) **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`. SpeedDial - acces rapid la site-uri favorite, cu posibilitate de organizare pe domenii; eu folosesc în acest fel 169 de legături; oferă şi un mic preview  

  

DownThemAll - un download manager general, oferă control şi monitarizare mai bune  

  

DownloadHelper - util şi uşor de folosit pentru a descărca conţinut audio/foto/video, mai ales de tip FLASH  

  

GmailNotifier - un notificator pentru multiple conturi de gmail  

  

StatusbarEX - afişează informaţii despre utilizarea memoriei (inclusiv cea consumată de Firefox), a procesorului, viteza reţelei etc  

  

BrowserProtect - întăreşte securitatea la atacuri "hijack"  

  

FasterFox - îmbunătăţeşte performanţa reţelei, la navigare  

  

FlagFox - afişează un mic steguleţ al ţării unde este localizat serverul accesat prin locaţia curentă (dacă reuşeşte o identificare)  

  

AddBlock îl folosesc şi eu