am un tel nokia 1.3, am băgat un card micro sd, de memorie și l-am șters din greșeală.cum îl pot recupera?
Îl scoți imediat, îl pui într-un adaptor și apoi îl bagi într-un calculator / laptop și cu programul recuva ai putea recupera chiar tot.
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) Evident ca gresesti.Obtii ceva de genul kg2 etc. buna ziua,

trebuie vazuta. daca doriti, ma puteti contacta la 0724.223.626 si sa colaboram pentru a va ajuta sa o vindeti rapid. Se poate! Nu folosi consolidarea cunostiintelor, din pagina de start mergi direct la capitolul unde crezi ca ai probleme si da click pe subcapitolul respectiv. 
De exemplu, daca vei da click pe culori, vei avea posibilitatea sa recapitulezi culorile: <http://prntscr.com/90vo4g> am raspuns astazi la o intrebare similara. va rog cautati in raspunsurile de mai sus cere-i un act de proprietate si un act de identitate! sau mergeti impreuna la un notar public si va ajuta el! mulțumesc. bună ziua. aveți nevoie de un număr de românia cel mai probabil. încercați să introduceți numărul unei cunoștințe. multumesc pentru raspuns. **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`.