setați funcții. Înțelegerea funcției set(). Declarație de clasă într-un dosar separat

Set() este o colecție neordonată fără elemente duplicat. Cu toate acestea, nu îmi pot da seama cum generează rezultatul.

De exemplu, luați în considerare următoarele:

Nu ar trebui set(y): set() output? Le-am încercat pe acestea două în Python 2.6.

5 soluții colectează formularul web pentru „Înțelegerea funcției set()”

După cum spuneți, seturile sunt neordonate. În timp ce o modalitate de a implementa seturi este de a folosi un arbore, acestea pot fi implementate și folosind un tabel hash (adică cheile în ordinea sortată ar putea să nu fie la fel de banale).

Dacă doriți să le sortați, puteți doar să faceți:

Sortat(set(y))

În caz contrar, singurul lucru stabilit este garantat este că face elementele unice (nimic nu va fi mai mult de o dată).

Sper că acest lucru vă ajută!

Ca tip de colecție neordonat, set() este echivalent cu set() .

Deși ar fi mai bine să afișați conținutul setului în ordine sortată, ceea ce ar face apelul repr() mai scump.

Intern, tipul de set este implementat folosind un tabel hash: o funcție hash este utilizată pentru a împărți elementele în mai multe găleți pentru a reduce numărul de operații de egalitate necesare pentru a verifica dacă un element face parte dintr-un set.

Pentru a crea o ieșire repr(), pur și simplu scoate elementele din fiecare găleată pe rând, ceea ce este puțin probabil să fie în ordine.

Ca și volatilitatea și ați subliniat, seturile sunt neordonate. Dacă doriți ca elementele să fie în ordine, sunați sortat pe platou:

>>> y = >>> sortat(set(y))

Seturile Python (și dicționarele) vor repeta și se vor imprima niste ordine, dar exact ceea ce va fi în acea ordine va fi arbitrar și nu este garantat să rămână același după adăugare și eliminare.

Următorul este un exemplu de modificare a ordinii stabilite după adăugare un numar mare valori și eliminarea ulterioară:

>>> s = set() >>> print(s) (8, 1, 6) >>> s.update(range(10,100000)) >>> pentru v în interval(10, 100000): s .remove(v) >>> print(e) (1, 6, 8)

Este dependent de implementare și, prin urmare, nu ar trebui să vă bazați pe el.

Astăzi am pus aceeași întrebare și am primit răspunsul la acest răspuns. Îmi este încă greu să înțeleg De ce setul este stricat.

I-am menționat asta partenerului meu și el a venit cu această metaforă: ia marmura. Le pui într-un tub puțin mai lat decât lățimea marmurei: ai o listă. Setul este însă o geantă. Chiar dacă introduceți marmura una câte una în pungă; când le turnați din pungă înapoi în tub, nu vor fi în aceeași ordine (pentru că sunt toate amestecate în pungă).

Clasele și obiectele în C++ sunt conceptele de bază ale programării orientate pe obiecte - OOP. Programarea orientată pe obiecte este o extensie a programării structurate în care conceptele de bază sunt conceptele de clase și obiecte. Principala diferență dintre limbajul de programare C++ și C este că nu există clase în C și, prin urmare, limbajul C nu acceptă OOP, spre deosebire de C++.

Pentru a înțelege de ce sunt cu adevărat necesare clase, să facem o analogie cu un obiect din Viata de zi cu zi, de exemplu, cu o bicicletă. O bicicletă este un obiect care a fost construit după planuri. Și astfel, aceste desene joacă un rol al claselor în OOP. Astfel, clasele sunt niște descrieri, scheme, desene în funcție de care sunt create obiecte. Acum este clar că pentru a crea un obiect în POO, trebuie mai întâi să întocmești planuri, adică clase. Clasele au propriile lor funcții, care sunt numite metode de clasă. Mișcarea bicicletei se realizează datorită rotației pedalelor, dacă luăm în considerare bicicleta din punctul de vedere al OOP, atunci mecanismul de pedalare este o metodă de clasă. Fiecare bicicletă are propria sa culoare, greutate, diverse componente - toate acestea sunt proprietăți. Mai mult, fiecare obiect creat poate avea proprietăți diferite. Având o singură clasă, puteți crea un număr nelimitat de obiecte (biciclete), fiecare dintre ele va avea același set de metode, în timp ce nu trebuie să vă gândiți la implementarea internă a mecanismului de pedalare, roți, funcționare a sistemului de frânare , deoarece toate acestea vor fi deja definite în clasă. După ce ne-am ocupat de scopul clasei, îi vom oferi o definiție competentă.

Clasele în C++ este o abstractizare care descrie metode, proprietăți, obiecte care nu există încă. Obiecte- o reprezentare concretă a unei abstracțiuni care are proprietăți și metode proprii. Obiectele create pe baza unei clase sunt numite instanțe ale acelei clase. Aceste obiecte pot avea un comportament, proprietăți diferite, dar vor fi totuși obiecte din aceeași clasă. În OOP, există trei principii principale pentru construirea claselor:

1. Încapsulare este o proprietate care vă permite să combinați atât datele, cât și metodele care lucrează cu acestea într-o clasă și să ascundeți detaliile de implementare de la utilizator.
2. Moştenire este o proprietate care vă permite să creați o nouă clasă copil pe baza uneia existente, în timp ce toate caracteristicile clasei părinte sunt atribuite clasei copil.
3. Polimorfismul- o proprietate a claselor care vă permite să utilizați obiecte de clasă cu aceeași interfață fără informații despre tipul și structura internă a obiectului.

Vom acoperi fiecare clasă de clădire în detaliu, după cum este necesar, dar pentru moment, amintiți-vă de aceste trei. Acum să revenim la clase, mai întâi să ne uităm la structura declarațiilor de clasă.

// declararea claselor în clasa C++ /*numele clasei*/ ( private: /* lista de proprietăți și metode de utilizare în interiorul clasei */ public: /* lista de metode disponibile pentru alte funcții și obiecte de program */ protejat: / *lista facilitatilor , accesibila prin mostenire*/ );

Declarația de clasă începe cu rezervat cuvânt cheie clasă urmat de numele clasei. în paranteze, liniile 3 - 10 se declară corpul clasei, iar după paranteza de închidere este necesar să se pună punct și virgulă, linia 10. Trei etichete de specificații de acces sunt declarate în corpul clasei, liniile 4, 6, 8, Fiecare etichetă trebuie să fie urmată de două puncte. V linia 4 eticheta specificatorului de acces este declarată privată. Toate metodele și proprietățile unei clase declarate după specificatorul de acces privat vor fi accesibile numai în cadrul clasei. V linia 6 specificatorul de acces public este declarat, toate metodele și proprietățile clasei declarate după specificatorul de acces public vor fi disponibile pentru alte funcții și obiecte din program. În timp ce ne oprim aici, nu vom analiza acum specificatorul de acces protejat, doar amintiți-vă că este acolo. Când se declară o clasă, nu este necesar să se declare cei trei specificatori de acces și nu este necesar să le declare în această ordine. Dar este mai bine să decideți imediat cu privire la ordinea declarării specificatorilor de acces și să încercați să vă respectați. Să dezvoltăm un program în care declarăm cea mai simplă clasă, în care va fi declarată o funcție care imprimă un mesaj.

folosind namespace std; // începutul declarației clasei clasa CppStudio // numele clasei ( public: // specificatorul de acces void message() // funcție (metoda clasei) care afișează un mesaj pe ecran ( cout<< "website: сайт\ntheme: Classes and Objects in C + +\n"; } }; // конец объявления класса CppStudio int main(int argc, char* argv) { CppStudio objMessage; // объявление объекта objMessage.message(); // вызов функции класса message system("pause"); return 0; }

V liniile 7 - 14 am definit o clasă numită CppStudio. Este obișnuit ca numele unei clase să înceapă cu o literă majusculă, iar cuvintele ulterioare din nume trebuie să înceapă și cu o literă majusculă. Această combinație de litere se numește caz de cămilă, deoarece alternanța literelor mari și mici seamănă cu silueta unei cămile. Specificatorul de acces public este declarat în corpul clasei, ceea ce permite altor funcții să apeleze metodele clasei declarate după public . De aceea în funcția principală, în linia 19 am putut apela funcția message(). In clasa CppStudio este declarată o singură funcție, care nu are parametri și afișează pe ecran un mesaj, linia 12 . Metodele de clasă sunt aceleași funcții, doar că sunt declarate în interiorul clasei, deci tot ce are legătură cu funcții este relevant și pentru metodele de clasă. Declararea claselor se realizează în mod similar cu declararea funcțiilor, adică o clasă poate fi declarată într-un fișier separat sau în fișierul principal, mai târziu vom vedea cum se face acest lucru. V linia 18 este declarată variabila objMessage de tip CppStudio, deci variabila objMessage este un obiect al clasei CppStudio. Astfel, o clasă este un tip de date complex. După ce obiectul clasei este declarat, puteți utiliza metodele acestuia. Există o singură metodă - funcția message(). Pentru a face acest lucru, apelăm metoda obiectului objMessage printr-un punct, așa cum se arată în linia 19, ca urmare, programul va afișa un mesaj text (vezi Figura 1).

Site web: tema site-ului web: Clase și obiecte în C++

Figura 1 - Clase în C++

set - funcții și get - funcții de clasă

Fiecare obiect are unele proprietăți sau atribute proprii care îl caracterizează de-a lungul vieții sale. Atributele unui obiect sunt stocate în variabilele declarate în cadrul clasei căreia îi aparține obiectul. Mai mult, declararea variabilelor trebuie efectuată cu specificatorul de acces privat. Astfel de variabile sunt numite elemente de date. Deoarece elementele de date sunt declarate private, numai metodele de clasă le pot accesa, accesul extern la elementele de date este interzis. Prin urmare, se obișnuiește să se declare metode speciale în clase - așa-numitele funcții set și get, cu care puteți manipula elementele de date. setați funcții inițializați membrii datelor, obține funcții vă permit să vizualizați valorile elementelor de date. Să modificăm clasa CppStudio astfel încât să poată stoca data în format zz.ll.aa. Pentru a schimba și vizualiza data, implementăm funcțiile set și, respectiv, get.

// classes.cpp: definește punctul de intrare pentru aplicația consolă. #include „stdafx.h” #include folosind namespace std; class CppStudio // numele clasei ( private: // specificatorul de acces private int zi, // zi luna, // luna an; // an public: // specificatorul de acces public void message() // funcția (metoda clasei) care scoate o mesaj pe ecran (cout<< "\nwebsite: сайтntheme: Classes and Objects in C + +\n"; } void setDate(int date_day, int date_month, int date_year) // установка даты в формате дд.мм.гг { day = date_day; // инициализация день month = date_month; // инициализация месяц year = date_year; // инициализация год } void getDate() // отобразить текущую дату { cout << "Date: " << day << "." << month << "." << year << endl; } }; // конец объявления класса CppStudio int main(int argc, char* argv) { setlocale(LC_ALL, "rus"); // установка локали int day, month, year; cout << "Введите текущий день месяц и год!\n"; cout << "день: "; cin >> zi; cout<< "месяц: "; cin >> luna; cout<< "год: "; cin >> an; CppStudio objCppstudio; // declarație obiect objCppstudio.message(); // apelarea funcției clasei de mesaje objCppstudio.setDate(zi, lună, an); // data initializării objCppstudio.getDate(); // afișează sistemul de date(„pauză”); returnează 0; )

Definiția clasei are un nou specificator de acces privat, linia 9. Acest specificator de acces restricționează accesul la variabilele care sunt declarate după el și înainte de începerea specificatorului de acces public, liniile 9 - 12. Astfel, variabilele zi, luna, an pot fi accesate doar prin metodele clasei. Funcțiile care nu aparțin clasei nu pot accesa aceste variabile. Membrii de date sau metodele de clasă declarate după specificatorul de acces privat dar înainte de începutul următorului specificator de acces sunt numiți membri de date private și metode de clasă privată. Urmând principiul cel mai mic privilegiu și principiul bunei programări, este logic să declari membrii datelor după specificatorul de acces privat și metodele de clasă după specificatorul de acces public. Apoi, pentru a manipula elementele de date, sunt declarate funcții speciale - get și a stabilit. Am adăugat două metode setDate() și getDate() la clasa CppStudio, să aruncăm o privire mai atentă la fiecare metodă. Metoda setDate() este definită cu 18 până la 23 de rânduri. După cum sa menționat anterior, set - funcții inițializați membrii datelor, astfel încât metoda setDate() îndeplinește doar o astfel de funcție. Adică, metoda setDate() inițializează variabilele zi, lună, an. Pentru a vizualiza valorile din elementele de date private, se declară funcția getDate(), care returnează valorile din variabilele zi, lună, an ca dată, completând astfel definiția clasei, în main(), ca întotdeauna, creăm un obiect de clasă și, prin intermediul obiectului, numim metodele acestuia rândurile 39 - 41. Dacă membrii datelor ar fi declarați după specificatorul public, ne-am putea referi la ei în același mod ca și la metodele de clasă. Rezultatul programului este prezentat în Figura 2.

Introduceți ziua, luna și anul curent! zi: 10 luni: 11 an: 2011 site: ntheme: Clase și obiecte în C++ Data: 10/11/2011

Figura 2 - Clase în C++

Constructorii

În programul anterior, elementele de date au fost declarate în clasa CppStudio care poate stoca informații despre dată. Când a fost creat obiectul de clasă, am sunat mai întâi set - funcție, pentru a seta data curentă (inițializand astfel elementele de date), și apoi a apelat obține - funcțieși am văzut data corespunzătoare pe ecran. Dacă am sunat mai întâi obține - funcție, apoi în loc de dată am vedea niște numere - gunoi. Deci, atunci când creați obiecte, puteți inițializa imediat elementele de date ale clasei, constructorul îndeplinește această funcție. Constructor- o functie speciala care realizeaza initializarea initiala a elementelor de date, iar numele constructorului trebuie neaparat sa se potriveasca cu numele clasei. O diferență importantă între un constructor și alte funcții este că nu returnează deloc valori, inclusiv void . Orice clasă trebuie să aibă un constructor, chiar dacă constructorul nu este declarat explicit (ca și în clasa anterioară), compilatorul oferă un constructor implicit fără parametri. Să îmbunătățim clasa CppStudio adăugând un constructor la ea.

// classes.cpp: definește punctul de intrare pentru aplicația consolă. #include „stdafx.h” #include << "\nwebsite: сайт\ntheme: Classes and Objects in C + +\n"; } void setDate(int date_day, int date_month, int date_year) // установка даты в формате дд.мм.гг { day = date_day; // инициализация день month = date_month; // инициализация месяц year = date_year; // инициализация год } void getDate() // отобразить текущую дату { cout << "date: " << day << "." << month << "." << year << endl; } }; // конец объявления класса CppStudio int main(int argc, char* argv) { CppStudio objCppstudio(11,11,2011); // объявление объекта и инициализация элементов данных objCppstudio.message(); // вызов функции message objCppstudio.getDate(); // отобразить дату system("pause"); return 0; }

// cod Cod::Blocuri

// Cod Dev-C++

// classes.cpp: definește punctul de intrare pentru aplicația consolă. #include folosind namespace std; clasa CppStudio // numele clasei ( privat: // specificator de acces privat int zi, // zi luna, // luna an; // an public: // specificator de acces public CppStudio(int date_day, int date_month, int date_year) // constructor de clasă ( setDate(data_day, date_month, date_year); // apelarea funcției de setare a datei ) void message() // funcție (metoda clasei) care afișează un mesaj pe ecran ( cout<< "\nwebsite: сайт\ntheme: Classes and Objects in C + +\n"; } void setDate(int date_day, int date_month, int date_year) // установка даты в формате дд.мм.гг { day = date_day; // инициализация день month = date_month; // инициализация месяц year = date_year; // инициализация год } void getDate() // отобразить текущую дату { cout << "date: " << day << "." << month << "." << year << endl; } }; // конец объявления класса CppStudio int main(int argc, char* argv) { CppStudio objCppstudio(11,11,2011); // объявление объекта и инициализация элементов данных objCppstudio.message(); // вызов функции message objCppstudio.getDate(); // отобразить дату return 0; }

Constructorul este declarat în rândurile 13 - 16. Constructorul are trei parametri prin care primește informații despre dată, în corpul constructorului se numește set — funcție pentru a seta data. A fost posibil să se implementeze inițializarea inițială a membrilor clasei fără set - funcții, dar deoarece această funcție a fost furnizată, ar fi mai corect să utilizați această funcție, linia 15. V linia 35 declarăm un obiect de clasă, iar după numele obiectului dintre paranteze rotunde trecem trei argumente. Acesta este modul în care constructorul efectuează inițializarea inițială a membrilor datelor (vezi Figura 3).

Website: tema site-ului: Clase și obiecte în C++ data: 11/11/2011

Figura 3 - Clase în C++

Declarație de clasă într-un dosar separat

Până acum, declarația de clasă se făcea într-un fișier cu funcția principală și totul funcționa. Să presupunem că trebuie să scrieți un fel de program, pentru aceasta trebuie să utilizați clasa CppStudio - clasa pe care am dezvoltat-o ​​mai devreme. Pentru a utiliza această clasă, trebuie să includeți fișierul în care este declarată. După cum am spus deja, fișierele sunt incluse folosind directiva #include preprocesor. Dar chiar dacă putem include fișierul cu clasa, va apărea o nouă problemă - deoarece fișierul cu clasa conține deja funcția main(), compilatorul va genera o eroare la construirea proiectului. Esența erorii: „Multiple main() găsite în proiect - functii." De aceea clasa trebuie declarată într-un fișier separat pentru a putea fi folosită în mod repetat. Anterior, am declarat funcțiile într-un fișier separat, în același mod în care o clasă este plasată într-un fișier separat. Pentru a face acest lucru, trebuie să urmați 3 pași:

1. declarăm o clasă personalizată în fișierul antet, în cazul nostru CppStudio ;
2. conectați fișierul antet la program, în cazul nostru — #include „CppStudio.h” .

În funcție de mediul de dezvoltare, modalitățile de a adăuga fișiere la proiect pot diferi, dar esența sarcinii nu se schimbă. În MVS2010, fișierul antet poate fi adăugat apelând meniul contextual (clic dreapta) în „ explorator de soluții"prin selectarea" creați un nou element". În caseta de dialog care apare, selectați tipul de fișier de care avem nevoie — acesta este *.h și completați câmpul " Nume de fișier". Ca și înainte, alegem un nume semnificativ, de obicei același cu numele clasei. Acum un nou fișier antet a fost adăugat la proiectul nostru - CppStudio.h .

În fișierul antet nou creat, declarăm clasa și, dacă este necesar, includem anteturi suplimentare. Iată ce ar fi trebuit să se întâmple:

// fișier antet CppStudio.h #include folosind namespace std; // declarația clasei clasa CppStudio // numele clasei ( private: // specificatorul de acces private int zi, // zi luna, // luna an; // an public: // specificatorul de acces public CppStudio(int data_day, int data_luna, int date_year) // constructor de clasă ( setDate(data_day, date_month, date_year); // apelarea funcției de setare a datei ) void message() // funcție (metoda clasei) care afișează un mesaj pe ecran ( cout<< "nwebsite: сайтntheme: Classes and Objects in C + +n"; } void setDate(int date_day, int date_month, int date_year) // установка даты в формате дд.мм.гг { day = date_day; // инициализация день month = date_month; // инициализация месяц year = date_year; // инициализация год } void getDate() // отобразить текущую дату { cout << "date: " << day << "." << month << "." << year << endl; } }; // конец объявления класса CppStudio

Pentru ca funcția main să vadă clasa pe care am creat-o și să o poată folosi, trebuie să includem definiția clasei în executabil, cu funcția main(). Se face astfel:

// cod Cod::Blocuri

// Cod Dev-C++

// classes.cpp: definește punctul de intrare pentru aplicația consolă. // include clasa CppStudio #include "CppStudio.h" int main(int argc, char*argv) ( CppStudio objCppstudio(11,11,2011); // declararea obiectului și inițializarea elementelor de date objCppstudio.message(); // funcții de apelare mesaj objCppstudio.getDate(); // afișează sistemul de date ("pause"); return 0; )

V linia 5 este inclusă definiția clasei CppStudio, numai după aceea puteți crea obiecte de clasă, utilizați metodele acesteia etc. Rezultatul programului este exact același ca înainte, doar structura proiectului s-a schimbat.

Separarea interfeței de implementare

Interfață de clasă- un construct care definește metodele și proprietățile oferite de clasă. Implementarea clasei este o modalitate de a implementa sănătatea unei clase. Înainte de aceasta, nu am separat interfața clasei de implementarea acesteia, adică implementarea metodelor a fost efectuată în interiorul clasei. Separarea interfeței de implementarea clasei se face pentru a ascunde modul de funcționare a clasei. Separarea interfeței de implementare se face în 5 pași:

1. adăugați fișierul antet *.h la proiect;
2. definiți interfața de clasă în fișierul antet
3. adăugați un fișier executabil *.cpp la proiect;
4. execută implementarea clasei în fișierul executabil;
5. conectați fișierul antet la program.

Știm deja cum să adăugăm un fișier antet la un proiect, fișierul executabil este adăugat în același mod, numele acestor fișiere sunt de obicei date la fel. Interfața clasei ar trebui să arate astfel:

// Fișier antet clasă CppStudio // interfață de clasă // clasa declarație de clasă CppStudio // nume clasă ( privat: // specificator de acces private int zi, // zi lună, // lună an; // an public: // specificator de acces public CppStudio(int, int, int); // constructor de clasă void message(); // funcție (metoda de clasă) care afișează un mesaj pe ecran void setDate(int, int, int); // setarea datei în dd format.mm.yy void getDate(); // afișează data curentă); // sfârșitul declarației clasei CppStudio

Variabilele și prototipurile declarate ale metodelor de clasă au rămas în interfața clasei. Acum să ne uităm la conținutul fișierului de implementare a metodelor de clasă.

// fișierul de implementare a clasei CppStudio.cpp #include folosind namespace std; // conectează interfața clasei la fișierul său de implementare #include "CppStudio.h" CppStudio::CppStudio(int date_day, int date_month, int date_year) // constructor de clasă ( setDate(date_day, date_month, date_year); // apelează data funcția de setare ) void CppStudio::message() // funcție (metoda clasei) care afișează un mesaj pe ecran ( cout<< "nwebsite: сайтntheme: Classes and Objects in C + +n"; } void CppStudio::setDate(int date_day, int date_month, int date_year) // установка даты в формате дд.мм.гг { day = date_day; // инициализация день month = date_month; // инициализация месяц year = date_year; // инициализация год } void CppStudio::getDate() // отобразить текущую дату { cout << "date: " << day << "." << month << "." << year << endl; }

Pentru a lega o interfață de clasă și implementarea acesteia, trebuie să includeți un fișier antet cu definiția clasei în fișierul de implementare, linia 6(linie evidențiată). După aceea, puteți declara metode de clasă. Metodele de clasă sunt declarate în același mod ca și funcțiile, doar înainte de numele metodei trebuie să scrieți numele clasei și să puneți operația de rezoluție a scopului unar " :: «.

// sintaxă pentru declararea metodelor clasei în afara corpului clasei /*return data type*/ /*class name*/::/*method name*/(/*method parameters*/) ( // operatori )

Deoarece metodele de clasă sunt declarate în afara corpului clasei, este necesar să se asocieze implementarea metodei cu clasa, iar pentru aceasta vom folosi operația binară de rezoluție scope. O operație de rezoluție a domeniului binar leagă o metodă declarată extern la o clasă al cărei nume se potrivește cu numele din declarația metodei. De aceea trebuie să adăugați numele clasei și o operație de rezoluție a domeniului în declarația metodei clasei.

Deci, interfața clasei este definită, metodele clasei sunt declarate, rămâne să conectați fișierul antet din fișierul executabil cu funcția main() și programul este gata.

// classes.cpp: definește punctul de intrare pentru aplicația consolă. #include "stdafx.h" // include clasa CppStudio #include "CppStudio.h" int main(int argc, char*argv) ( CppStudio objCppstudio(11,11,2011); // declararea obiectului și inițializarea elementelor de date objCppstudio.message(); // funcția de apelare mesaj objCppstudio.getDate(); // afișează sistemul de date(„pauză”); return 0; )

// cod Cod::Blocuri

// Cod Dev-C++

// classes.cpp: definește punctul de intrare pentru aplicația consolă. // include clasa CppStudio #include "CppStudio.h" int main(int argc, char*argv) ( CppStudio objCppstudio(11,11,2011); // declararea obiectului și inițializarea elementelor de date objCppstudio.message(); // funcții de apelare mesaj objCppstudio.getDate(); // afișează data returnată 0; )

V linia 5 conectăm fișierul antet al clasei, după care puteți crea obiecte din această clasă.

Câteva sfaturi despre cum să formați interfața viitoarei clase și ce ar trebui sau nu ar trebui făcut pentru aceasta.

Una dintre caracteristicile cele mai frecvent solicitate în Windows 10 este capacitatea de a crea file separate în Exploratorul de fișiere implicit (peste 20.000 de voturi). După introducerea filelor în Internet Explorer 6 printr-o extensie specială încă din 2005, Microsoft a rezistat de mulți ani ideii de a adăuga file în Explorer sau orice altă aplicație, dar foarte curând situația se va inversa. Gigantul software vă va permite într-adevăr să creați file în orice aplicație pentru Windows 10. Funcționalitatea corespunzătoare se numește Seturi.

Testerii beta Windows Insider selectați îl vor putea încerca în săptămânile următoare. În același timp, dezvoltatorii nu au numit încă termeni specifici pentru disponibilitatea funcționalității pentru toți utilizatorii Windows 10.

Rețineți că, pentru prima dată, această funcționalitate a devenit cunoscută în aprilie. La acel moment, funcția era deținută sub numele de lucru Tabbed Shell.

La început, funcționalitatea Seturi va funcționa numai cu aplicații universale construite pe Platforma Universal Windows (UWP). Dezvoltatorii se așteaptă să colecteze cantitatea maximă de feedback și recomandări înainte de a implementa orice îmbunătățiri. Cu toate acestea, este foarte probabil ca în viitor seturile să nu se limiteze numai la aplicațiile UWP, ci să suporte și programele desktop tradiționale Win32/x86.

Esența ideii de seturi este reflectată pe deplin în titlu. Funcționalitatea vă permite să creați seturi de file legate de execuția unei anumite sarcini. Lucrând cu un document în Word, de exemplu, utilizatorul începe să caute rezultate ale cercetării și alte date despre subiect pe web sau să folosească propriile schițe din note. Deci, pentru comoditate, poate combina toate aplicațiile utilizate pentru un anumit proiect într-o singură fereastră. Funcția Seturi vă permite să comutați între diferite aspecte ale aplicațiilor, separând totul în funcție de sarcină.

Microsoft are planuri mari pentru seturi care se extind cu mult dincolo de sistemul de operare desktop Windows 10. Similar cu Timeline, o altă caracteristică interesantă a Windows 10 care ar trebui să fie disponibilă pentru testeri în următoarea versiune de testare Windows 10, Seturile vă vor permite să lucrați cu aplicații ajungând la ei.accesul de pe diverse dispozitive. Adică, va fi posibil să începeți lucrul pe un computer și apoi să continuați din același loc în care a fost întrerupt pe orice alt computer sau smartphone. O evaluare vizuală a capabilităților funcției Seturi permite videoclipul oficial de mai jos:

Poate cel mai greu lucru de făcut pentru Microsoft este să asigure asistența adecvată de la terți. Cu siguranță, la început, funcționalitatea Seturilor va fi limitată la suita Office, Explorer, Notepad și browserul Edge.

În exterior, Seturile arată la fel ca o filă necompletată Microsoft Edge. Funcția acceptă și căutarea universală.

Și această mișcare a Microsoft de a împinge integrarea browserului Microsoft Edge în toate aplicațiile Windows 10 ridică câteva întrebări. Mai mult, gigantul software a fost deja „ars” din cauza acestei abordări. În 2001, Departamentul de Justiție al SUA a început un litigiu cu Microsoft pentru decizia acestuia din urmă de a construi Internet Explorer direct în Windows. Cu toate acestea, piața s-a schimbat mult de atunci. În plus, fără funcționalitatea unui browser web, această interfață cu file nu are sens.

Din nou, în săptămânile următoare, Microsoft va începe să testeze funcționalitatea seturilor cu un număr limitat de testeri. Dezvoltatorii doresc să audă feedback din timp înainte de a începe testarea la scară largă.