am un laptop asa mai vechiut (asus x553m) si vreau sa ii pun un ssd. dupa cum stiti la acest model poti avea acces la hardware doar daca scoti tastatura. nu as vrea sa o scot si sa ii pun altul...? (mai mult)
am un laptop asa mai vechiut (asus x553m) si vreau sa ii pun un ssd. dupa cum stiti la acest model poti avea acces la hardware doar daca scoti tastatura. nu as vrea sa o scot si sa ii pun altul deoarece mi-e frica sa nu stric vreo componenta. oare ssd extern indeplineste aceeasi functii ca unul intern? si daca da care sa il iau?
nu il voi folosi decat pentru muzica, scoala online, filme si cateva jocuri old school
(scuze daca am ales categoria gresita)
pai, nu indeplineste aceleasi functii. pe cel intern se afla fisierele sistemului, programelor, etc. care sunt solicitate in permanenta, iar pe cel extern solicitarile sunt facute manual de catre tine.
poti instala ce vrei pe ssd-ul extern, insa, tine mine!, unele programe sunt dependente de sistemul si fisierele din sistemul pe care au fost instalate, adica ele nu pun fisiere numai in locatiile cunoscute, ci stocheaza setari, preferinte, etc. si in alte locatii precum appdata si mai rar in folderul-mama, iar, de altfel, majoritatea jocurilor necesita anumite librarii de functii din fisiere continute in pachetele de visual c++, asta fac jocurile mai putin portabile pe alte sisteme.
depinde de laptop. Astea mai noi de 3-4 ani incoace, au sistem de protectie a bateriei. Odata ce bateria este incarcata circuitul se va face direct catre laptop si nu prin baterie. Aceasta ramanand rece si incarcata. Deci e bine cand stai la laptop sa fie bagat mereu in priza.

 Daca descarci bateria de 5 ori pe zi in maxim 1-2 ani poti sa o arunci la gunoi.

 Bateriile de laptop sunt destul de firave si o buna pastrare a autonomie este destul de complicata. Sunt destul site-uri unde poti citi despre asta. Eu sunt de aceeasi parere cu asexe: un computer depinde de o minte umana ca sa fie alimentat cu informatii si programe. Are viteza de procesare mai mare decat a creierului uman si poate inmagazina mai multe date; dar, daca e adevarata chestia cu utilizarea a doar 10% din capacitatile creierului, la dimensiunile pe care le are... va dati seama ce eficienta presupune asta? Un calculator, daca vrei sa ii cresti performantele, trebuie sa il perfectionezi, sa il miniaturizezi... De fapt, el a fost creat in scopul de a-l ajuta pe om, nu de a-i fi egal (nicidecum superior). Si haideti sa nu ne gandim numai la chestii "tehnice": omul este creativ, in toate sensurile acestui cuvant; un calculator nu va fi in stare sa scrie o poezie, sa picteze un tablou, sa compuna o piesa de teatru sau un concert... nu va fi capabil sa gaseasca solutia cea mai buna intr-un caz de forta majora (daca nu are incarcat programul corespunzator sau daca programatorul nu a intuit necesitatea unei anumite optiuni... face si calculatorul ce poate!). Apoi, un calculator este static si dependent de curent. Eu cred ca ar trebui luate in calcul mai multe aspecte, ca sa putem decide daca ar fi mai "eficient". Probabil ca, la un moment dat, va fi posibila crearea de cyborg-i. Dar noi inca nu suntem capabili sa gasim solutii la probleme cotidiene cu care ne confruntam de multi ani... iar stiinta este in permanenta miscare... Cine stie ce se va mai descoperi? Poate ca va veni ziua in care - vorba lui Iosif - ne vom planta placute in cap, sa ne intensifice activitatea cerebrala; si, atunci, robotii vor fi iarasi devansati... :)  

  

Oricum... ar fi bine ca aceasta inteligenta artificiala sa nu scape de sub controlul omului, ca am putea avea mari belele... Si sa nu imi spuneti ca am vazut prea multe filme SF... lucruri care in urma cu vreo cateva zeci de ani parea de-a dreptul imposibile, azi fac parte din viata celor de gradinita... ;) nu toate optiunile disponibile pe laptop sunt disponibile si pe telefon. [[classroom]](https://aws1.discourse-cdn.com/business20/uploads/digitalnation/original/2x/7/75d184414e7193df5f8e5b39e42dc81b6810acfc.png "classroom") Nr.


Aici sunt mai multe exemple de ce:


1. Cod șablon este imposibil de a scrie cu excepția caietul de sarcini,


șablon
void f( T k )
{
T x( k );
x.x();
}
Copiile ar putea arunca, parametrul care trece ar putea arunca, și `x()` s-ar putea arunca unele necunoscute excepție.


2. Excepție-caietul de sarcini tind să interzică extensibilitate.


virtual void open() throw( FileNotFound );


ar putea evolua în


virtual void open() throw( FileNotFound, SocketNotReady, InterprocessObjectNotImplemented, HardwareUnresponsive );


Ai putea chiar scrie ca


arunca( ... )


Primul nu este extensibil, cel de-al doilea este un proiect mult prea ambițios și cel de-al treilea este într-adevăr ceea ce vrei să spui, atunci când scrie funcții virtuale.


3. Cod moștenire


Atunci când scrie cod care se bazează pe o altă bibliotecă, nu't știu ce ar putea face atunci când ceva nu merge oribil greșit.


int lib\_f();


void g() throw( k\_too\_small\_exception )
{
int k = lib\_f();
dacă( k < 0 ) arunca k\_too\_small\_exception();
}


"g" se va termina, când lib\_f()`aruncă. Aceasta este (în cele mai multe cazuri), nu ceea ce vrei cu adevărat.`std::termina()` nu ar trebui să fie numit. Este întotdeauna mai bine să lăsați aplicația accident cu o excepție netratată, de la care puteți prelua un stack trace, decât la tăcere/violent muri.


4. Scrie cod care returnează erori comune și aruncă în ocazii excepționale.


Eroarea e = open( "bla.txt" );
if( e == FileNotFound )
MessageUser( "Fișier bla.txt nu a fost găsit" );
if( e == AccessDenied )
MessageUser( "nu a Reușit să deschidă bla.txt, pentru că nu ne't au citit drepturile ..." );
dacă( e != Succes )
MessageUser( "nu a Reușit din cauza la un alt eroare, codul de eroare = " + itoa( e ) );


încercați
{
std::vector k( 1000 );
// ...
}
a prinde( const bad\_alloc& b )
{
MessageUser( "de memorie, ieșirea procesului de" );
arunca;
}


Cu toate acestea, atunci când bibliotecă doar aruncă-ți de propriile excepții, puteți utiliza excepție caietul de sarcini a stat intenția ta. [**DeepCool DP-N9**](https://l.profitshare.ro/l/5794533) este cel mai bun cooler pentru laptop

Conceput pentru a intalni cu succes asteptarile celor care cauta nu numai un cooler eficient, dar si cel mai silentios cooler pentru laptop, modelul cu flux de aer vertical DP-N9 constituie un produs superior calitativ de la DeepCool.

[**Deepcool N2 Kawaii Style**](https://l.profitshare.ro/l/5794536)

Modelul Kawaii Style nu numai ca ofera eficienta sporita la un pret convenabil, dar are si un design foarte simpatic. Este vorba despre un cooler ce poate fi utilizat ca dimensiune pentru un laptop cu diagonala pana in 17 inch si are incorporat un ventilator cu flux vertical de aer, cu diametrul de 18 cm.

[**DeepCool Multi Core X8**](https://l.profitshare.ro/l/5794540)

Fiind pus pe piata atelierele renumitului producator de coolere DeepCool, modelul Multi Core X8 este un dispozitiv compatibil ca dimensiune cu latopurile cu diagonala de 17 inch. Este confectionat din aluminiu si plastic rezistent, pentru a permite eficienta maxima si durabilitate sporita. **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`. depinde pentru ce doriti sa cumparati? Deși nu am't testat personal, am motive să cred că cele de mai sus menționate LA COMANDA soluție va lucra pentru XP, 2000 și 2003 Server. Per meu și Bryant's de testare, ne-am'am identificat că aceeași abordare nu funcționează cu windows Vista sau Windows Server 2008-cel mai probabil, din cauza adăugat de securitate și /interactive comutator depreciată. 


Cu toate acestea, am dat peste aceasta [articolul](http://verbalprocessor.com/2007/12/05/running-a-cmd-prompt-as-local-system), care demonstrează utilizarea de [PSTools](http://download.sysinternals.com/files/PSTools.zip) de la [SysInternals](http://sysinternals.com/) (care a fost achiziționat de către Microsoft în iulie, 2006.) Am lansat linia de comandă prin următoarele și dintr-o dată am fost difuzate în temeiul Locale de Administrare Cont ca magic:



```
psexec -i -s cmd.exe
```

PSTools funcționează bine. L's ușor, bine documentate set de instrumente care oferă o soluție adecvată la problema mea.


Multe mulțumiri pentru cei care au oferit ajutor. Presupunând că utilizați Debian. 


Versiunea Scurta:



1. Sistem de Backup
2. Scoateți principal și partiții swap (lăsând la partitia de boot singur)
3. Recrea partiția principală de a utiliza restul de spațiu pe disc (cu excepția boot partitona). Asigurați-vă că pentru a reutiliza același sector de start ca originalul partiția rădăcină.
4. reporniți sistemul
5. redimensiona noul boot in partitia root pentru a utiliza pe deplin dimensiunea partiției.


Instrucțiuni pas cu pas



În primul rând a face o copie de rezervă de pe Cardul SD folosind instrucțiunile de [aici](https://raspberrypi.stackexchange.com/questions/311/how-do-i-backup-my-raspberry-pi) în cazul în care ceva nu merge bine.


De la linia de comandă sau o fereastră de terminal introduceți următoarele



```
sudo fdisk /dev/mmcblk0
```

atunci de tip " p " pentru a lista tabela de partiții 


ar trebui să vezi trei partiții. dacă te uiți în ultima coloană etichetată **Sistem** trebuie să aveți 


1. W95 FAT32
2. Linux
3. Linux Swap


asigurați-o notă de numărul de pornire pentru partitona 2, veți avea nevoie de asta mai târziu. deși probabil va fi în continuare pe ecran (doar în cazul). 


următor tip  **" d "**  pentru a șterge o partiție.


Apoi vi se va cere pentru numărul de partiția pe care doriți să o ștergeți. În cazul de mai sus care doriți să o ștergeți atât Linux și Linux swap partiții.


Deci tipul **`2`** 


apoi tastați  **" d "**  din nou, apoi tastați **`3`** pentru a șterge partiția de swap.


Acum puteți redimensiona partiția principală. 


tip **`n`** pentru a crea o nouă partiție.


Această nouă partiție trebuie să fie o partitie primara atât de tip  **"p"**.


Apoi introduceți **`2`** când vi se solicită pentru o partiție număr.


Acum ți se va cere pentru primul sector pentru noua partiție.
**Introduceți un număr de pornire** de la începutul pas (partitia de Linux)


Vi se va cere pentru ultimul sector puteți doar **apăsați enter pentru a accepta valoarea implicită** care vor utiliza restul de spațiu pe disc.


Tip **`w`** pentru a salva modificările făcute.


Repornire sistem cu următoarea comandă:



```
sudo reboot
```

odată ce sistemul a reporni și te-ai întors la commandline introduceți următoarea comandă:



```
sudo resize2fs /dev/mmcblk0p2
```

Notă: acest lucru poate dura o lungă perioadă de timp (în funcție de card dimensiune și viteză) să fie pacient și să-l termine, astfel încât să nu strica sistemul de fișiere și trebuie să înceapă de la zero. 


Odată ce se face reporniți sistemul cu următoarea comandă:



```
sudo reboot
```

Acum puteți verifica dacă sistemul este folosind întreaga capacitate a Cardului SD, introducând următoarea comandă:



```
df -h
```

De Ce Funcționează:



Adevărata magie aici este că **ștergeți root si swap partiții, apoi recrea numai partiția root (folosind de start inițială, sector) înainte de a scrie datele pe disc**. Ca urmare nu't șterge datele existente la partiția rădăcină. 


Prin eliminarea partiția de swap vă permite partiția root cameră să crească dincolo de dimensiunea sa actuală și umple porțiunea neutilizată de disc (pentru că de plasament de partiții -partiția root este prins între pornire și partiții swap - se poate't pur și simplu să fie redimensionate lăsând partiție de swap singur). 


Apoi redimensiona (care este sigur pentru a rula pe un disc montat) sistemul de fișiere pentru a utiliza tot spațiul în partiția root.


ref: 


* [http://www.youtube.com/watch?v=R4VovMDnsIE](https://www.youtube.com/watch?v=R4VovMDnsIE)
* [http://www.raspberrypi.org/phpBB3/viewtopic.php?f=5&t=5584](https://www.raspberrypi.org/phpBB3/viewtopic.php?f=5&t=5584) 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.