C Perusteet (2)_developdoc

C-perusteet (2)

2024-07-12

Sisällysluettelo

1. Luokat ja objektit

1.1 Luokan määritelmä

1.2 Käyttöoikeudet

1.3 Luokan verkkotunnus

2. Instantiaatio

2.1 Instantiation käsite

2.2 Objektin koko

3.tämä osoitin

4. Luokkien oletusjäsenfunktiot

4.1 Rakentaja

4.2 Tuhoaja

4.5 Kuljettajan ylikuormitus

1. Luokat ja objektit

1.1 Luokan määritelmä

Luokan määritelmän muoto

luokka on avainsana, joka määrittelee luokan, Pino on luokan nimi ja {} on luokan runko. Huomaa, että määritelmän lopussa olevaa puolipistettä ei jätetä pois. Luokan rungon sisältöä kutsutaan luokan jäseniksi: luokan muuttujia kutsutaan attribuuteiksi tai luokan jäsenmuuttujia luokan menetelmiksi tai jäsenfunktioiksi.


//text.cpp
#include<iostream>
using namespace std;
 
class Stack
{
 
	//成员变量
	int* a;
	int top;
	int  capacity;
	//成员函数
	void Push()
	{
 
	}
	void Pop()
	{
 
	}
};//分号不能省略
int main()
{
	
 
	return 0;
}

Jäsenmuuttujien erottamiseksi on yleensä tavallista lisätä jäsenmuuttujaan erityinen tunniste, kuten alkava _ tai m_ ennen tai jälkeen jäsenmuuttujan.Tälle C++-syntaksille ei ole säännöksiä, se on vain henkilökohtainen tai yrityksen mieltymys.


//为区分成员变量，一般前面加_
//成员变量
int* _a;
int _top;
int  _capacity;

Struct C++:ssa voi myös määritellä luokkia C++:ssa. Samalla struct on päivitetty luokkaan silti suosittelemme käyttämään luokkaa luokkien määrittämiseen.

Luokassa määritellyt jäsenet ovat oletuksena rivissä

1.2 Käyttöoikeudet

C++ on tapa toteuttaa kapselointi, jossa luokkien avulla yhdistetään objektin ominaisuuksia ja menetelmiä objektin tekemiseksi täydellisemmäksi ja valikoivasti tarjotaan sen käyttöliittymä ulkoisille käyttäjille käyttöoikeuksien kautta.

Julkisesti (julkinen) muokattuihin jäseniin pääsee suoraan luokan ulkopuolelta, suojatulla (suojattu) ja yksityisellä (yksityinen) muokattuihin jäseniin ei pääse suoraan luokan ulkopuolelta, suojattu ja yksityinen ovat samat.
Käyttöoikeuden laajuus alkaa kohdasta, jossa käyttöoikeus näkyy, kunnes seuraava käyttöoikeustunnus ilmestyy.


//text.cpp
#include<iostream>
using namespace std;
 
class Stack
{
 
	
	///
 
	void Push()
	{
 
	}
	//Push 没给限定符 class默认私有 private 
	///
public:
	void Pop()
	{
 
	}
	int Swap()
	{
 
	}
	//Pop和Swap 被public修饰，直到下一个限定符出现之前都为公有
	///
protected:
	int add();
//add 被public修饰，直到下一个限定符出现之前都为保护
/// /
 
private:
 
	int* _a;
	int _top;
	int  _capacity;
//成员变量被private修饰，直到}结束都为私有
};
int main()
{
	Stack st;
	//公有可以访问
	st.Pop();
	st.Swap();
	//私有不可访问
	st._top;
 
 
 
	return 0;
}

Lisämerkinnät:

Kun pääsytunnistimet eivät muuta luokan määritelmän jäseniä, ne ovat oletuksena yksityisiä ja struct oletusarvoisesti public.
Yleensä jäsenmuuttujat rajoitetaan yksityisiin/suojattuihin, ja jäsenfunktiot, joita muiden on käytettävä, sijoitetaan julkisiksi.

1.3 Luokan verkkotunnus

Luokka määrittelee uuden laajuuden. Kaikki luokan jäsenet ovat luokan ulkopuolella.

Luokkatoimialue vaikuttaa kääntämisen hakusääntöihin. Jos seuraavan ohjelman Init ei määritä luokan pinoa, kääntäjä käsittelee Initiä globaalina funktiona. Jos se ei löydä kääntämisen aikana jäseniä, kuten _top, se siirtyy luokan verkkotunnus löytää ne.


//text.cpp
#include<iostream>
using namespace std;
 
class Stack
{
 
 
public:
	void Init(int x, int y);
 
};
void Stack::Init(int x, int y)
 
	{
		 _top = x;
		 _capacity = y;
	}
int main()
{
	
	return 0;
}

Ilmoitus:

Luokan funktiomääritykset ja -määritykset erotetaan toisistaan. Luokan luomisen jälkeen muodostetaan uusi luokka-alue.

2. Instantiaatio

2.1 Instantiation käsite

Tyypin luomista fyysiseen muistiin kutsutaan luokan ilmentymiseksi.
Luokka on objektin abstrakti kuvaus. Se rajoittaa luokan jäsenmuuttujia, eikä tilaa varata.


//text.cpp
#include<iostream>
using namespace std;
 
class Stack
{
 
//声明
 
	int* _a;
	int _top;
	int  _capacity;
 
};
 
int main()
{
	
	Stack::_top = 2024;
	//编译器报错，_top只是声明，并未实例化
 
	return 0;
}

Luokka voi instantoida useita objekteja, ja instantoidut objektit vievät todellista fyysistä tilaa ja tallentavat jäsenmuuttujia. Esimerkiksi: esineiden luominen luokasta on kuin arkkitehtonisten suunnittelupiirustusten käyttäminen talon rakentamiseen. Luokat ovat kuin suunnittelupiirustukset rakennus, ja se ei voi Asua ihmisissä, vain kun talo on rakennettu suunnittelupiirustusten mukaan, ihmiset voivat asua talossa.Sama luokka on kuin suunnittelupiirros. Se kertoo kääntäjälle, kuinka paljon muistia aiotaan avata, mutta se ei avaa muistia.


//text.cpp
#include<iostream>
using namespace std;
 
class Stack
{
 
 
//声明
	int* _a;
	int _top;
	int  _capacity;
 
};
 
int main()
{
	
	
	Stack st;
    st._top=2024;
//Stack实例化出st，系统已经给st分配内存了，可以存储数据，编译通过
 
	return 0;
}

2.2 Objektin koko

Analysoi mitä jäseniä luokkaobjektilla on? Jokaisella luokan instantoimalla objektilla on itsenäinen tietoavaruus, joten objektin tulee sisältää jäsenmuuttujia. Onko siis jäsenfunktioita mukana? Ensinnäkin, kun funktio on käännetty, se on käskyosio, jota ei voi tallentaa objektiin. Nämä käskyt tallennetaan erilliselle alueelle (koodisegmentti), joka voi olla vain osoitin jäsentoiminto. Pitääkö objektiin tallentaa osoittimia d1 ja d2 Sekä di:llä että d2:lla on itsenäiset jäsenmuuttujat _vuosi/_kuukausi/_päivä, mutta jäsenfunktiot d1 ja d2. /Print-osoitin? on sama, ja se menee hukkaan, jos se varastoidaan esineeseen. Jos käytät päivämäärää 100 objektin ilmentämiseen, jäsenfunktioosoitin tallennetaan toistuvasti 100 kertaa, mikä on liian turhaa. Itse asiassa funktion osoitinta ei tarvitse tallentaa. Kutsuva funktio käännetään kokoonpanokäskyksi [kutsun osoite]. Itse asiassa kääntäjän on löydettävä funktion osoite Sitä ei löydy ajon aikana. Tila löytyy ajon aikana, joten funktion osoite on tallennettava.

Muistin kohdistussäännöt

Ensimmäinen jäsen on osoitesiirrossa 0 rakenteesta
Muut jäsenmuuttujat on kohdistettava osoitteisiin, jotka ovat tasausnumeron kerrannaisia.
Tasausnumero = Kääntäjän oletuskohdistusnumero ja jäsenen koko pienempi
VS x64 -alustan oletuskohdistusnumero on 4 ja x86:n oletuskohdistusnumero on 8
Rakenteen kokonaiskoko on: suurimman kohdistusluvun kokonaislukukerrannainen (suurin kaikista tyyppimuuttujista ja pienin oletuskohdistusnumero)
Jos rakenteet ovat sisäkkäisiä, sisäkkäinen rakenne kohdistetaan sen oman enimmäiskohdistusluvun kokonaislukukerrannaiseen, ja rakenteen kokonaiskoko on kaikkien maksimikohdistuslukujen kokonaislukukerrannainen (mukaan lukien sisäkkäisten rakenteiden kohdistusmäärä).


class A
{
public:
	void Print()
	{
		cout << _ch << endl;
	}
private:
	char _ch;
 
	int _i;
};
//_ch 是一个字节，默认对齐数是4，最大对齐数是4，所以开辟4个字节用来存在_ch
// _i是4个字节，默认对齐数是4，最大对齐数是4，所以开辟4个字节用来存储_i
class B
{
public:
	void Print()
	{
	//。。。
	}
 
	
};
class B
{
 
 
};
//B和C里面没有存储任何成员变量，只有一个函数，可成员函数不存对象里面
// 按理来说是0，但是结构体怎么会没大小，为表示对象存在C++对这种规定大小为1，为了占位标识对象存在

3.tämä osoitin

Kun kääntäjä on käännetty, luokan jäsenfunktiot lisäävät osoittimen nykyiseen luokkaan oletusarvoisesti muodollisen parametrin ensimmäiseen kohtaan, jota kutsutaan nimellä tämä osoitin.

Esimerkiksi Date-luokan Init-prototyyppi on void Init (Päivämäärä * const this, int vuosi, int kuukausi, int päivä) Kun päästään jäsenmuuttujiin luokan jäsenfunktioissa, essenssiin päästään tämän osoittimen kautta. kuten _year Init-funktiossa, tämä->_vuosi=vuosi

prototyyppi:


class Date
{
	void Print()
	{
 
		cout << _year << "n" << _month << "n" << _day << endl;
	}
	void Init( int year, int month,int day)
	{
		_year = year;
		_month = month;
		_day = day;
 
	}
	
private:
	int _year;
	int _month;
	int _day;
 
};


Date d1;
d1.Init(2024,7,10);
 
d1.Print();
Date d2;
 
d2.Init(2024, 7, 9);
d2.Print();

todellinen prototyyppi


class Date
{
	void Init(Date* const this,int year, int month,int day)
	
	{
		this->_year = year;
		this->_month = month;
		this->_day = day;
 
	}
	void Printf(Date* const this)
	
	{
 
		cout << this->_year << "n" <<this-> _month << "n" << this->_day << endl;
	}
private:
	int _year;
	int _month;
	int _day;
 
};


Date d1;
d1.Init(&d1,2024,7,10);
d1.Print(&d1);
 
Date d2;
d2.Init(&d2,2024, 7, 9);
d2.Print();

C++ määrää, että tätä osoitinta ei saa kirjoittaa todellisten parametrien ja muodollisten parametrien paikkaan (kääntäjä käsittelee sen käännettäessä), mutta tätä osoitinta voidaan käyttää eksplisiittisesti funktion rungossa tämän osoittimen osoittama sisältö voi

tämä osoitin on tallennettu pinoon

4. Luokkien oletusjäsenfunktiot

Oletusjäsenfunktio on jäsenfunktio, jota käyttäjä ei ole erikseen määritellyt ja jonka kääntäjä luo automaattisesti. Sitä kutsutaan oletusjäsenfunktioksi.

4.1 Rakentaja

Konstruktori on erityinen jäsenfunktio On huomattava, että vaikka konstruktoria kutsutaan rakentajaksi, konstruktorin pääsisältö ei ole avata tilaa objektien luomiseksi (yleensä käyttämämme paikallinen objekti on tila, joka avataan, kun se avataan. pinokehys luodaan) ), mutta objekti alustetaan, kun objekti instantoidaan. Konstruktorin ydin on korvata aiemmin pino- ja päivämääräluokissa kirjoittamamme Init-funktio. Konstruktorin automaattinen kutsu korvaa täydellisesti Init-funktion.

Rakentajan ominaisuudet:

Toiminnon nimi on sama kuin luokan nimi
Ei paluuarvoa (sinun ei tarvitse antaa mitään palautusarvona, äläkä kirjoita void-arvoa. Tämä on C++:n sääntö)
Kun objekti on instantoitu, järjestelmä kutsuu automaattisesti vastaavaa rakentajaa.
Rakentajat voivat olla ylikuormitettuja
Jos luokassa ei ole määritetty eksplisiittistä konstruktoria, C++-kääntäjä luo automaattisesti parametrittoman oletuskonstruktorin Kun käyttäjä on nimenomaisesti määrittänyt rakentajan, kääntäjä ei enää luo sitä.


class Date
{public:
	//1.无参构造函数
	Date()
	{
		_year = 1;
		_month = 1;
		_day = 1;
	}
	//2.带参构造函数
	Date(int year, int month, int day)
{
		_year = year;
		_month = month;
		_day = day;
	}
 
 
	//3.全缺省构造函数
	Date(int year = 1, int month = 1, int day = 1)
	{
		_year = year;
		_month = month;
		_day = day;
	}
private:
	int _year;
	int _month;
	int _day;
 
};

Parametritonta rakentajaa, täysin oletuskonstruktoria ja kääntäjän oletusarvoisesti luomaa konstruktoria, kun emme kirjoita konstruktoria, kutsutaan kaikkia oletuskonstruktoreiksi. Mutta vain yksi näistä kolmesta voi olla olemassa, ei samanaikaisesti. Vaikka parametriton konstruktori ja täysi oletuskonstruktori muodostavat funktion ylikuormituksen, niitä kutsuttaessa esiintyy epäselvyyttä.Huomaa, että oletuskonstruktorin lisäksi kääntäjä ei ole oletuksena luonut, vaan se on konstruktori, parametriton konstruktori, ja koko oletuskonstruktori on myös oletuskonstruktori.

Emme kirjoita sitä. Kääntäjän luomalla konstruktilla ei ole oletuksena vaatimuksia sisäänrakennettujen jäsenmuuttujien alustamiselle, eli on epävarmaa, onko se alustettu vai ei, se riippuu kääntäjästä.


//text.cpp
#include<iostream>
using namespace std;
typedef int STDataType;
class Stack
{
public:
	Stack(int n = 4)
	{
		_a = (STDataType*)malloc(sizeof(STDataType) * n);
		if (nullptr == _a)
		{
			perror("malloc申请失败");
		}
		_capacity = n;
		_top = 0;
	}
 
private:
	STDataType* _a;
	size_t _capacity;
	size_t _top;
};
//两个Stack实现队列
class MyQueue
{
private:
    int size;
	Stack pushst;
	Stack popst;
};
 
int main()
{
 
	MyQueue my;
 
 
	return 0;
}

C++ jakaa tyypit mukautetuiksi tyypeiksi ja sisäänrakennetuiksi tyypeiksi (perustyypit). Sisäänrakennetut tyypit ovat kielen tarjoamia alkuperäisiä tietotyyppejä, kuten int/char/double/pointer jne. Mukautetut tyypit ovat tyyppejä, jotka määrittelemme itse käyttämällä avainsanoja, kuten class/struct.Konstruktori alustetaan tässä automaattisesti, ja VS alustaa myös sisäänrakennetun tyyppikoon. Eri kääntäjillä on erilaiset alustusarvot, eikä C++ määritä niitä.

Mukautetun tyypin jäsenmuuttujien osalta on kutsuttava tämän jäsenmuuttujan oletuskonstruktori sen alustamiseksi.Jos tällä jäsenmuuttujalla ei ole oletuskonstruktoria, raportoidaan virhe. Jos haluamme alustaa tämän jäsenmuuttujan, meidän on käytettävä alustusluetteloa sen ratkaisemiseksi.

Yhteenveto: Useimmissa tapauksissa meidän on toteutettava rakentaja itse. Muutamissa tapauksissa se on samanlainen kuin MyQueue ja kun Stackilla on oletuskonstruktori, MyQueue voidaan luoda ja käyttää automaattisesti.

4.2 Tuhoaja


~Stack()
{
	free(_a);
	_a = nullptr;
	_top = _capacity = 0;
}

Destruktorin ominaisuudet:

1. Destruktorin nimeä edeltää merkit~

2. Ei parametreja eikä palautusarvoa (yhdenmukainen rakentajan kanssa)

3. Luokassa voi olla vain yksi tuhoaja.Jos määritelmää ei näytetä, järjestelmä luo automaattisesti oletushävittäjän.

4. Kun objektin määritysjakso päättyy, järjestelmä kutsuu automaattisesti tuhoajan.

5. Samoin kuin rakentaja, emme kirjoita kääntäjän automaattisesti luomaa destruktoria emmekä käsittele sisäänrakennettuja mukautetun tyypin jäseniä, jotka kutsuvat muita tuhoajia.

6. On myös huomattava, että kun näytämme destructorin, kutsutaan myös mukautetun tyypin jäsenen tuhoajaa, mikä tarkoittaa, että mukautetun tyypin jäsenen tuhoaja kutsutaan automaattisesti tilanteesta riippumatta.


//text.cpp
#include<iostream>
using namespace std;
typedef int STDataType;
class Stack
{
public:
	Stack(int n = 4)
	{
		_a = (STDataType*)malloc(sizeof(STDataType) * n);
		if (nullptr == _a)
		{
			perror("malloc申请失败");
		}
		_capacity = n;
		_top = 0;
 
 
	}
 
	~Stack()
	{
		free(_a);
		_a = nullptr;
		_top=_capacity=0;
	}
private:
	STDataType* _a;
	size_t _capacity;
	size_t _top;
	
};
//两个Stack实现队列
class MyQueue
{public:
    //编译器默认生成MyQueue的构造函数调用了Stack的构造，完成了两个成员的初始化
	//编译器默认生成MyQueue的析构函数调用了Stack的析构，释放了Stack内部的资源
	//显示写析构也会调用Stack的析构
	~MyQueue()
	{
		cout << "~MyQueue" << endl;
	}
private: 
	
	Stack pushst;
	Stack popst;
	
};
 
 
int main()
{
 
	MyQueue my;
 
 
	return 0;
}

MyQueuen tuhoaja ei tee mitään, mutta C++ edellyttää, että muita tuhoajia kutsutaan vapauttamaan muisti.

Jos resursseja ei pyydetä, destruktoria ei tarvitse kirjoittaa, ja kääntäjän luomaa oletusdestruktoria voidaan käyttää suoraan, kuten Date. Jos luotua oletusdestruktoria voidaan käyttää, tuhoajaa ei tarvitse kirjoittaa erikseen kuten MyQueue, mutta siellä on resurssisovellus

4.5 Kuljettajan ylikuormitus

Kun operaattoreita käytetään kirjoitetuissa objekteissa, C++-kielen avulla voimme määrittää uusia merkityksiä operaattorin ylikuormituksen muodossa. C++ edellyttää, että kun luokkatyyppinen objekti käyttää operaattoria, se on muutettava kutsuksi vastaavalle operaattorin ylikuormitukselle. Jos ei, kääntäjä ilmoittaa virheestä.
Operaattorin ylikuormitus on funktio, jolla on tietty nimi Sen nimi koostuu operaattorista ja myöhemmin määritettävästä operaattorista.Kuten muillakin funktioilla, sillä on myös palautustyyppi ja parametriluettelo sekä funktion runko


 
 
bool operator<(Date d1, Date d2)
{
 
}
bool operator==(Date d1,Date d2)
{
	return d1._year == d2._year && d1._month == d2._month && d1._day == d2._day;
}

Ylikuormitettu käyttötoiminto ottaa yhtä monta parametria kuin ne parametrit, joihin käyttäjä vaikuttaa.Unaarisella siirtomukavuudella on yksi parametri ja binäärioperaattorilla kaksi parametria. Binäärioperaattorin vasen operandi välitetään ensimmäiseen parametriin ja oikea operandi toiseen parametriin.


//text.cpp
#include<iostream>
using namespace std;
 
class Date
{
public:
	Date(int year, int month, int day)
	{
	_year= year;
		_month = month;
		_day = day;
 
	}
 
 
 
	int _year;
	int _month;
	int _day;
 
};
 
bool operator<(Date d1, Date d2)
{
 
}
bool operator==(Date d1,Date d2)
{
	return d1._year == d2._year && d1._month == d2._month && d1._day == d2._day;
}
int main()
{
 
	Date d1(2024, 7, 10);
	Date d2(2024,7,9);
//两种用法都可以
	d1 == d2;
	operator==(d1 , d2);
	return 0;
}

Jos ylikuormitettu operaattorifunktio on jäsenfunktio, sen ensimmäinen operandi välitetään oletuksena implisiittiselle osoittimelle. Siksi, kun operaattori on ylikuormitettu jäsenfunktiona, sillä on yksi parametri vähemmän kuin operandi.
Kun operaattori on ylikuormitettu, sen ensisijaisuus ja assosiatiivisuus pysyvät yhdenmukaisina sisäänrakennettujen tyyppitoimintojen kanssa.
Et voi luoda seksuaalista operaattoria ketjuttamalla osumia, joita ei ole syntaksissa: esim. operator@.

Teknologian jakaminen

C-perusteet (2)

1. Luokat ja objektit

1.1 Luokan määritelmä

1.2 Käyttöoikeudet

1.3 Luokan verkkotunnus

2. Instantiaatio

2.1 Instantiation käsite

2.2 Objektin koko

3.tämä osoitin

4. Luokkien oletusjäsenfunktiot

4.1 Rakentaja

4.2 Tuhoaja

4.5 Kuljettajan ylikuormitus

Henkilökohtainen profiili

yhteystietoni