o simpla intrebare:

pot programa c++ in notepad-ul normal din windows 7?
nu, pentru a face asta iti trebui un ide ca devc++ sau codeblocks.
**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`. 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. Membrii privați sunt accesibile doar în cadrul clasei definirea ei.


Protejate membrii sunt accesibile în clasa pe care le definește și în clasele care moștenesc de la clasa respectivă.


Edit: Ambele sunt, de asemenea, accesibil de prieteni din clasa lor, iar în cazul protejate de membri, de prietenii lor de clasele derivate.


Edit 2: Utilizați orice are sens în contextul problema ta. Ar trebui să încercați să facă membrii private ori de câte ori poți să reducă cuplare și de a proteja punerea în aplicare a clasei de bază, dar dacă asta's nu este posibil a folosi apoi protejate de membri. Verifica [C++ FAQ](https://isocpp.org/wiki/faq/basics-of-inheritance) pentru o mai bună înțelegere a problemei. [Această întrebare despre protejate variabile](https://stackoverflow.com/questions/37011/protected-member-variables) s-ar putea, de asemenea, de ajutor. Nu sunt sigur dacă ajută (am găsit Documentația ccnet oarecum inutil uneori):


[Utilizarea CruiseControl.NET cu MSTest](http://confluence.public.thoughtworks.org/display/CCNET/Using+CruiseControl.NET+with+MSTest) * Notă: a se vedea <http://www.jetbrains.net/devnet/message/5244658> pentru o altă versiune a acestui răspuns.


Citind posturile, se pare că există o anumită confuzie cu privire la întrebarea inițială. Lasă-mă să o lovitură de cuțit la ea.


Postul original este într-adevăr cere întrebarea: „Cum pot identifica și elimina referințele dintr-un proiect Visual Studio pentru alte proiecte / ansambluri care nu sunt în uz?“ Afișul vrea ansamblurile să nu mai apară ca parte a producției construi.


În acest caz, Resharper vă poate ajuta să *identificați* ei, dar trebuie să *eliminați* - le tine. 


Pentru a face acest lucru, deschide Referințe inth Solution Browser, faceți clic dreapta pe fiecare ansamblu de referință, și alege „Find Code dependent“. Vedea:


<http://www.jetbrains.com/resharper/features/navigation_search.html#Find_ReferencedDependent_Code>


Vei primi fie:


1. O listă a dependențele pe această referință într-o fereastră de browser, sau
2. Un dialog care vă spune „Codul dependent de XXXXXXX modul nu a fost găsit.“.


Dacă obține al doilea rezultat, puteți apoi să faceți clic pe mouse-dreapta Reference, selectați Eliminare și scoateți-l din proiectul dumneavoastră.


În timp ce trebuie sa la acest „manual“, adică o referință la un moment dat, se va face treaba. Dacă cineva a automatizat acest lucru într-un fel Sunt interesat de audiere cum a fost făcut.


Puteți ignora destul de mult pe cele din .Net Framework, deoarece nu, in mod normal copiate de ieșire dvs. construi (de obicei - cu toate că nu este neapărat adevărat pentru aplicațiile Silverlight).


Unele posturi par să fie răspunsul la întrebarea: „Cum pot elimina folosind clauzele (C #) dintr-un fișier de cod sursă care nu sunt necesare pentru a rezolva orice referințe în acel dosar“. 


În acest caz, Resharper ajută în câteva moduri:


1. Identifică folosind clauze neutilizate pentru timpul pe detectarea erorii zbura. Ele apar ca avertismente de inspecție de cod - codul va apărea culoarea gri (fie implicit) în fișierul și Resharper va oferi un indiciu pentru al elimina:


<http://www.jetbrains.com/resharper/features/code_analysis.html#On-the-fly_Error_Detection>
2. Vă permite să le eliminați în mod automat, ca parte a procesului de Cod Cleanup:


<http://www.jetbrains.com/resharper/features/code_formatting.html#Optimizing_Namespace_Import_Directives>


**În cele din urmă, dau seama că Resharper face analiza codul static pe soluția. Deci, dacă aveți o referință dinamică a ansamblului - spune prin reflecție sau un ansamblu care este încărcată dinamic în timpul rulării și accesate prin intermediul unei interfețe - nu se va ridica.**  Nu există nici un substitut pentru înțelegerea dvs. de baza codului și dependențele de proiect în timp ce lucra la proiectul dumneavoastră. Fac găsi Resharper caracteristici foarte utile. Am'am avut succes folosind [Mockito](https://github.com/mockito/mockito).


Când am încercat să aflu JMock și EasyMock, am găsit o curbă de învățare pentru a fi un pic abrupt (deși poate că's doar eu).


Îmi place Mockito din cauza naturii sale simple si curate, sintaxa că am fost capabil să înțeleagă destul de repede. Minim sintaxa este conceput pentru a sprijini frecvente cazuri foarte bine, deși de câteva ori am nevoie să fac ceva mai complicat, am găsit ceea ce am vrut a fost susținută și ușor de înțeles.


Aici's o (prescurtată) exemplu de Mockito pagina de start:



```
import static org.mockito.Mockito.*;

List mockedList = mock(List.class);
mockedList.clear();
verify(mockedList).clear();
```

Nu't obține mult mai simplu decât asta.


Singurul dezavantaj major, care mă pot gândi este că nu o't bate joc de metode statice. 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. Acest lucru pare să o facă pentru mine:



```
#+BEGIN_SRC emacs-lisp
(defadvice org-babel-execute-src-block (around load-language nil activate)
  "Load language if needed"
  (let ((language (org-element-property :language (org-element-at-point))))
    (unless (cdr (assoc (intern language) org-babel-load-languages))
      (add-to-list 'org-babel-load-languages (cons (intern language) t))
      (org-babel-do-load-languages 'org-babel-load-languages org-babel-load-languages))
    ad-do-it))
#+END_SRC

```

Cel puțin a funcționat pentru gnuplot (după ce am instalat
pachetul gnuplot și executabil). Git este foarte rapid, cântare foarte bine, și este foarte transparent despre conceptele sale. Partea de jos de acest lucru este faptul că are o relativ curbă de învățare abruptă. Un Win32 port este disponibil, dar nu destul de un prim-clasă cetățean. Git expune hash ca numere de versiune pentru utilizatori; aceasta oferă garanții (în care un singur hash se referă întotdeauna la același conținut; un atacator poate modifica istoria fără a fi detectat), dar poate fi dificil pentru utilizator. Git are un concept unic de urmărire conținutul fișierului, chiar și cei conținutul muta între fișiere și fișiere de vedere, ca prim nivel de obiecte, dar nu urmări directoare. O altă problemă cu git este că are multe operațiuni (cum ar fi *rebazare*), ceea ce face ușor de a modifica istoria (într-un sens, de conținut menționate de un hash nu se va schimba niciodată, dar referirile la acel hash pot fi pierdute); unii puriști (inclusiv eu) nu't place foarte mult.


Bazar este rezonabil de rapid (foarte rapid pentru arbori cu istorie superficială, dar în prezent cântare prost cu istoria lungime), și este ușor de a învăța de la cei familiarizați cu interfețe de linie de comandă tradiționale SCMs (CVS, SVN, etc). Win32 este considerat un prim-clasa țintă de către echipa de dezvoltare. Ea are o pluggable arhitectura pentru diferite componente, și înlocuiește său format de stocare frecvent; acest lucru le permite să introducă noi caracteristici (cum ar fi mai bine suport pentru integrarea cu revizuirea sistemelor de control bazate pe concepte diferite) și de a îmbunătăți performanța. Bazar echipa consideră directorul de urmărire și redenumiți-suport de prima clasa funcționalitate. În timp ce la nivel global unic de revizuire id-ul de identificare sunt disponibile pentru toate revizuirile, copac-locale revnos (revizuire standard de numere, mai asemănător cu cele folosite de svn sau alte mai convenționale SCMs) sunt folosite în loc de conținut hash-uri pentru identificarea revizii. Bazar are suport pentru "ușor case de marcat", în care istoria este tinut pe un server de la distanță în loc de copiat la sistemul local și este trimisă automat la rețea atunci când este necesar; în prezent, acest lucru este unic printre DSCMs.


Ambele au o formă de SVN integrarea disponibile; cu toate acestea, bzr-svn este capabil de mult mai mult decât git-svn, în mare parte datorită backend format modificările introduse în acest scop. *[Update, ca din 2014: Cel de-al treilea-petrecere produs comercial SubGit oferă o interfață bidirecțională între SVN și Git care este comparabil în fidelitatea față de bzr-svn, și mult mai lustruit; I **puternic** recomanda utilizarea lui pe care de git-svn când buget și de acordare a licențelor constrângeri permis].*


Nu am folosit Mercurial pe scară largă, și deci nu pot să comentez în detaliu-cu excepția să rețineți că, la fel ca Git, are un conținut-hash abordarea pentru revizii; de asemenea, astfel de Git, nu trateze directoarele ca prima-clasa de obiecte (și nu poate stoca un director gol). Cu toate acestea, este mai rapid decât orice alt DSCM cu excepția Git, si are mult mai bună IDE integrare (în special pentru Eclipsa) decât oricare dintre concurenții săi. Având în vedere caracteristicile de performanță (care gal-ul doar ușor în spatele celor de Git) și superior cross-platform și IDE sprijin, Mercurial poate fi convingătoare pentru echipe cu număr semnificativ de win32-centrice sau IDE-legat de membri.


O preocupare în migrarea de la SVN este că SVN's interfețe GUI IDE și integrare sunt mult mai matur decât cei de oricare dintre distribuite SCMs. De asemenea, dacă aveți în prezent face uz grele de precommit script de automatizare cu SVN (de exemplu. necesită o unitate de teste pentru a trece înainte de a o comite poate continua), nu'll, probabil, doriți să utilizați un instrument similar cu [PQM](https://launchpad.net/pqm) pentru automatizarea merge cereri de la filiale comune.


SVK este un DSCM care utilizează Subversiune ca sprijinul magazin, și are destul de buna integrare cu SVN-centrice instrumente. Cu toate acestea, ea are în mod dramatic mai rău de performanță și scalabilitate caracteristici decat orice alt mare DSCM (chiar Darcs), și ar trebui să fie evitate pentru proiecte care sunt de natură să crească mare în termeni de lungime de istorie sau numărul de fișiere.


[Despre autor: eu folosesc Git și vrând-Nevrând de muncă, și Bazar pentru proiectele mele personale și ca o funcție de bibliotecă; alte părți ale angajatorului meu's utilizare organizația Mercurial puternic. Într-o viață anterioară am construit o mare de automatizare jurul SVN; înainte de asta am experiență cu GNU Arc, BitKeeper, CV-uri și altele. Git fost destul off-punerea în prim-am simtit ca Arch GNU în măsura în care a fi un concept greu de mediu, spre deosebire de instrumente construite pentru a se conforma la utilizator's gamă de fluxuri de lucru ... dar m-am'am ajuns să fie destul de confortabil cu ea]. O JIT compiler ruleaza **după** programul a început și compilează codul (de obicei bytecode sau un fel de NEG instrucțiuni) pe zbor (sau doar-în-timp, ca's) într-o formă care's, de obicei, mai repede, de obicei gazda CPU's nativi set de instrucțiuni. O JIT are acces la execuție dinamică informații întrucât un compilator standard nu't și poate face mai bine optimizări ca inlining funcții care sunt utilizate frecvent.


Acest lucru este în contrast cu un tradițional compiler care compilează **toate** codul de limbaj mașină **înainte** programul este primul a alerga.


Pentru a parafraza, convenționale compilatoare construi întregul program ca un fișier EXE ÎNAINTE de prima dată când îl rulați. Pentru noi programe de stil, un ansamblu este generat cu pseudocod (p-code). Numai DUPĂ ce executați programul pe sistemul de OPERARE (de exemplu, prin dublu-clic pe pictograma acestuia) va (JIT) compiler lovi cu piciorul în și de a genera cod mașină (m-code) care Intel bazate pe procesor sau orice altceva va înțelege.