Botúin Choitianta i gClárchlárú C++ agus Conas iad a Shocrú
Tá ríomhchlárú C++ ar cheann de na teangacha ríomhchlárúcháin is cumhachtaí agus is solúbtha. Leis an gcumas atá aici tacú le ríomhchlárú nós imeachta, dírithe ar réada, agus cineálach, úsáidtear C++ go forleathan i réimse leathan feidhmchlár, ó chórais oibriúcháin go feidhmchláir chearrbhachais ardfheidhmíochta. Mar sin féin, cosúil le haon teanga ríomhchlárúcháin, tá roinnt earráidí coitianta ag C++ freisin a bhíonn ag forbróirí, idir nua agus taithí acu, go minic. Pléifidh an t-alt seo roinnt earráidí coitianta i ríomhchlárú C++ agus cuirfidh sé treoir ar fáil maidir le conas iad a shocrú.
1. Úsáid a bhaint as Pointeoirí Neamhthosaithe
Earráid:
Is féidir le pointeoir neamhthosaithe pointeáil chuig suíomh cuimhne anaithnid, rud a fhágann iompar gan choinne nó tuairteáil cláir. Seo sampla den earráid seo:
“`cpp
int ptr; // níl ptr tosaithe
ptr = 10; // Earráid: níor cuireadh tús leis an pointeoir
"`
Conas a Shocrú:
Tosaigh an pointeoir roimh úsáid. Is féidir leat é a thosú le `nullptr` nó le seoladh cuimhne bailí.
“`cpp
int ptr = nullptr; // Tosaigh le nullptr
luach int = 10;
ptr = &luach;
ptr = 20; // Sábháilte anois
"`
2. Earráidí i mBainistíocht Cuimhne (Sceitheadh Cuimhne)
Earráid:
Tarlaíonn sceitheadh cuimhne nuair nach n-athscaoiltear cuimhne leithdháilte. Is féidir leis seo a bheith ina chúis le feidhmchlár níos mó agus níos mó cuimhne a úsáid le himeacht ama, rud a fhágann ganntanas cuimhne sa deireadh.
“`cpp
int ptr = int nua[10];
// Dearmad a dhéanamh ar an gcuimhne leithdháilte a scriosadh
"`
Conas a Shocrú:
Déan cinnte i gcónaí cuimhne leithdháilte a shaoradh trí úsáid a bhaint as `delete` nó `delete[]` ag brath ar an méid a úsáideadh chun í a leithdháileadh.
“`cpp
int ptr = int nua[10];
// Úsáid chuimhne…
scrios[] ptr; // Cuimhne leithdháilte saor in aisce
"`
Bain úsáid as leabharlann pointeoirí cliste (amhail `std::unique_ptr` nó `std::shared_ptr`) chun bainistíocht cuimhne a dhéanamh níos éasca.
“`cpp
I measc
std::uathúil_ptr ptr(slánuimhir nua[10]);
// Scaoilfear cuimhne go huathoibríoch nuair a fhágann ptr an raon feidhme
"`
3. Botúin in Úsáid Tagairtí
Earráid:
Is féidir go mbeadh iompar gan choinne mar thoradh ar thagairt nó pointeoir a thabhairt ar ais chuig athróg áitiúil atá imithe lasmuigh dá raon feidhme.
“`cpp
int& faighTagairt() {
luach int = 10;
luach ar ais; // Earráid: tagairt á tabhairt ar ais chuig athróg áitiúil
}
"`
Conas a Shocrú:
Seachain tagairtí a thabhairt ar ais d'athróga áitiúla. Ina áit sin, bain úsáid as athróga statach, nó níos fearr fós, luachanna a thabhairt ar ais, nó smaoinigh ar réada a úsáid.
“`cpp
int faighLuach() {
luach int = 10;
luach ar ais; // Níos sábháilte
}
"`
4. Déan neamhaird de Theachtaireachtaí Earráide agus Rabhaidh an Tiomsaitheora
Earráid:
Is minic a dhéanann ríomhchláraitheoirí neamhaird ar theachtaireachtaí earráide agus rabhaidh a eisíonn an tiomsaitheoir, cé go soláthraíonn na teachtaireachtaí seo faisnéis thábhachtach faoi earráidí féideartha.
Conas a Shocrú:
Seiceáil agus tuig i gcónaí na teachtaireachtaí earráide agus na rabhaidh a ghineann an tiomsaitheoir. Cumasaigh rabhaidh ardleibhéil chun cód níos glaine a chinntiú.
Mar shampla i GCC, bain úsáid as an mbratach `-Wall` chun níos mó rabhaidh a ghiniúint.
“` bash
g++ -Wall -o clár main.cpp
"`
5. Earráid i Ró-ualach Oibreora
Earráid:
Is féidir le ró-ualach mícheart oibreora iompar gan choinne nó earráidí am rithe a chur faoi deara.
“`cpp
rang MyClass {
poiblí:
sonraí iomlána;
Oibreoir MoRang+ (const MoRang& eile) {
sonraí + sonraí eile a thabhairt ar ais; // Earráid: ba chóir MoRang a thabhairt ar ais
}
};
"`
Conas a Shocrú:
Cinntigh go dtugann an t-oibreoir ró-ualaithe an cineál cuí ar ais agus go gcoimeádann sé neamh-athróga an ranga.
“`cpp
rang MyClass {
poiblí:
sonraí iomlána;
Oibreoir MoRang+ (const MoRang& eile) {
Toradh MyClass;
toradh.sonraí = sonraí + sonraí.eile;
toradh a thabhairt ar ais; // Tugann réad ar ais ó MyClass
}
};
"`
6. Mí-úsáid Macraí
Earráid:
Uaireanta úsáidtear macraí iomarcach nó mícheart, rud a d’fhéadfadh earráidí a bheith mar thoradh air atá deacair a bhrath ag am rite.
“`cpp
sainmhínigh CEARNÓG(x) xx
toradh iomlán = CEARNÓG(5 + 1); // Earráid: is é an toradh 5 + 1 5 + 1
"`
Conas a Shocrú:
Cuir nathanna tairiseacha nó teimpléid in ionad macraí le haghaidh slándáil agus rialú cineáil níos fearr.
“`cpp
teimpléad
Cearnóg T(T x) {
filleadh xx;
}
int toradh = cearnóg(5 + 1); // Sábháilte le húsáid
"`
7. Mí-úsáid Feidhmeanna Stíl C
Earráid:
Ag baint úsáide as feidhmeanna stíl C cosúil le `strcpy` nó `sprintf` atá i mbaol róshreafa maoláin.
“`cpp
char src[] = "Haigh, a Dhomhanda!";
ceann scríbe char[5];
strcpy(dest, src); // Earráid: róshreabhadh maoláin
"`
Conas a Shocrú:
Bain úsáid as feidhmeanna C++ níos sábháilte ar nós `std::string` nó `std::vector`.
“`cpp
I measc
std::string src = “Haigh, a Dhomhanda!”;
std::string ceann scríbe = src;
"`
8. Neamhaird a thabhairt ar Bhrath Earráide
Earráid:
Déan neamhaird de sheiceáil earráide ar oibríochtaí ionchuir/aschur nó ar fheidhmeanna a d’fhéadfadh teip.
“`cpp
comhad std::ifstream(“sonraí.txt”);
// Earráid: níor seiceáil an raibh an comhad oscailte go rathúil
"`
Conas a Shocrú:
Seiceáil i gcónaí an raibh an oibríocht rathúil agus déileáil le hearráidí i gceart.
“`cpp
comhad std::ifstream(“sonraí.txt”);
má tá (!comhad) {
std::cerr << “Theip ar an gcomhad a oscailt” << std::endl;
1 ar ais;
}
"`
9. Cur i bhFeidhm Lúb Fo-Optamach
Earráid:
Is féidir le lúba neamh-optamacha laghdú a chur faoi deara i bhfeidhmíocht an chláir.
“`cpp
le haghaidh (int i = 0; i < vec.size(); i++) {
// Próiseas le vec[i]
// Earráid: glaoitear ar size() ar gach athrá
}
"`
Conas a Shocrú:
Lúba a bharrfheabhsú trí ghlaonna feidhme athchleachtacha a laghdú.
“`cpp
le haghaidh (std::size_ti = 0, n = vec.size(); i < n; i++) {
// Próiseas le vec[i]
}
"`
Bain leas as halgartaim STL ar nós `std::for_each` freisin le haghaidh tuilleadh optamaithe.
“`cpp
I measc
std::for_each(vec.begin(), vec.end(), [](int &luach) {
// Próiseas le luach
});
"`
10. Earráid i Láimhseáil Snáithe
Earráid:
Is féidir le drochláimhseáil snáitheanna dálaí rása nó bacainní a bheith mar thoradh air.
“`cpp
cuir rith neamhní() san áireamh {
// Earráid: D’fhéadfadh riocht rása tarlú
}
std::snáithe t1(rith);
std::snáithe t2(rith);
"`
Conas a Shocrú:
Bain úsáid as bunphrionsabail sioncrónaithe amhail mutexes chun coinníollacha rása agus bacainní a chosc.
“`cpp
cuir san áireamh
std::mutex mtx;
rith neamhní() {
std::lock_guard glas(mtx);
// Próiseas atá sábháilte ó choinníollacha rása
}
std::snáithe t1(rith);
std::snáithe t2(rith);
t1.join();
t2.join();
"`
Conclúid
Is teanga ríomhchlárúcháin chumhachtach agus solúbtha í C++, ach tá sí seans maith go ndéanfar earráidí coitianta inti freisin, go háirithe a bhaineann le bainistíocht cuimhne agus pointeora. Trí thuiscint a fháil ar na hearráidí seo agus trí fhios a bheith agat conas iad a shocrú, is féidir leat feidhmchláir níos iontaofa agus níos éifeachtaí a fhorbairt . Cuimhnigh aird a thabhairt i gcónaí ar theachtaireachtaí tiomsaitheora, uirlisí nua-aimseartha a úsáid a chabhraíonn leat cód sábháilte a scríobh , agus do scileanna a fheabhsú i gcónaí maidir le dea-chleachtais ríomhchlárúcháin C++ a thuiscint agus a chur i bhfeidhm.
