Technology sharing

한어Русский языкEnglishFrançaisIndonesianSanskrit日本語DeutschPortuguêsΕλληνικάespañolItalianoSuomalainenLatina

Tabula contentorum

1. Classes et objecta

1.1 Classis definitio

1.2 Access qualifiers

1.3 Classis domain

2. Instantiation

2.1 Instantiation conceptus

2.2 Object size

3.This indicatorum

4.Default munera of classes

4.1Constructor

4.2 Destructor

4.5 Operator obruuntur

---

1. Classes et objecta

1.1 Classis definitio

Classis definitio forma

genus est keyword quod genus definit, Stack est nomen classis, et {} est corpus classis. Contenta in genere corporis membra ordinis dicuntur: variabiles in genere attributa vel membrum variabilium classis vocantur;

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

• Ad differentias membri distinguendas, plerumque solet addere specialem identificantem sodali variabili, ut incipiendo ab _ vel m_ ante vel post membrum variabile.Nullae normae in hac syntaxi C++ sunt, sed agitur de optione personali vel societatis.

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

• Structure in C ++ classes quoque definire potest tamen suadeo utens genere definire classes.

• Socii definiuntur in genere default ad inline

1.2 Access qualifiers

C++ modus est ad effectum deducendi encapsulationis, utendo classes ad componendas proprietates et modos obiecti ad obiecti pleniorem reddendam, et selective praebent suam operam ad usores externos per accessum iurium.

• Sodales publici modificati extra classem directe accessi possunt, membra a tuta et privata ac privata (privata) directe extra genus accessi possunt, tuta et privata eaedem sunt.
• Accessus permissionis locus incipit ab eo loco, ubi permissio accessus apparet usque ad proximum accessum adjunctum apparet. Si nulla subsequentis accessus adjunctum est, scopum finit}, qui est finis classium.

//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;
}

Additional Notes:

1. Cum membra classis definitio accessu qualifiers non modificantur, privatis deficiunt, ac defaltas ad publicas instruunt.
2. Generaliter variabilium membrum ad privatum/tutum restringetur, et socius functiones quae ab aliis adhibendae sunt, publicae ponentur.

1.3 Classis domain

Classis novum ambitum definit. Omnia membra classis in ambitu classis sunt. Cum membra definiunt extra genus, necesse est utendi scopi operantis ad indicandum cuius generis ambitum membrum pertinet.

Classis domain afficit inquisitionis regulas compilation. Si Init in sequenti programmate classium domain non designat Stack, compilator munus globalem tractabit Init classis domicilii reperit.

//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;
}

Animadverte:

1. Munus declarationes ac definitiones in genere separantur. Postquam classis creatur, nova regio classis formatur.

2. Instantiation

2.1 Instantiation conceptus

• Processus creandi typum in memoria corporis physicae instantiatio classis appellatur.
• Classis est abstracta rei descriptio. Est quiddam simile exemplari.

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

• Classis multa obiecta instantiare potest, et res instantiatae actuales spatium physicum occupant et variabilium membrorum copia. Exempli gratia: res instantiating ex genere est sicut usus picturae architectonicae ad aedificandum domum in re. Classes sunt sicut ratio tractus aedificationem, et vivere in hominibus non potest, nisi cum domus aedificatur utens consilio tractus, homines habitare in domo possunt.Ex eodem genere est sicut ratio tractus.

• ​
  //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 Object size

• Analyse quae membra habet genus obiectum? Unumquodque objectum instantiatum per genus suum spatium independens habet, ergo objectum membrum variabilium continere debet. Primum, postquam munus exaratum est, sectio instructionum est, quae in obiecto condi non potest. Hae instructiones in area separata (segmentum codicem reponuntur). membrum munus. Num necesse est indices in obiecto condere? Date instantiates duo obiecta d1 et d2. idem est, et perit in obiecto condito. Si uteris Date ad instantiat 100 obiecta, membrum functionis monstratoris saepe 100 vicibus reponenda est, quod nimis prodigi est. Revera, monstratorem munus condi non oportet. Munus monstratorem est oratio In runtime non invenitur.

Memoria dam praecepta

• Primum membrum est ad electronica offset 0 ex structura
• Alterum membrum variabilium variabilium adponi debet ad inscriptiones quae multiplices noctis numeri sunt.
• Noctis numerus = Minor de defectu compilator alignment numero et magnitudine membri
• Defalta alignment numerus VS x64 suggestus est 4, et default alignment numerus x86 est 8
• Magnitudo totius structurae est: integer multiplex maximus numerus alignment (maximus omnis generis variabilis et minimus numerus alignment)
• Si structurae nidificantur, structura nidificata alignatur integro suo numero maximorum alignment, et altiore structurae magnitudo est numerus integer numerus omnium maximorum alignment (including alignment number of nidificated structures) ;

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.This indicatorum

Post compilator compilator, sodalis functiones classium monstratorem currenti addet in prima positione parametri formalis per defaltam, quae monstrator vocatur.

Exempli gratia, Prototypum Init in Date class vacuum est Init (Date * const hoc, int annum, int mensem, int diem). ut _year in Init function

exemplar:

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();
 

verum exemplar

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++ affirmat non licere hanc monstratorem scribere in positione parametri actualis et parametri formalis (compilator eam cum componendis tractabit), sed hic monstrator explicite in corpore functionis adhiberi potest contentus monstratur hoc regula can

Haec regula reposita est in ACERVUS

4.Default munera of classes

Defalta membrum munus est munus membrum quod ab utente expresse non definitur et ab ipso compilator generatur.

4.1Constructor

Constructor munus est speciale membrum. Animadvertendum est quod, quamvis conditor dicatur constructor, principale contentum conditoris non est spatium aperire ad res creandas (obiectum locale, quod solere utimur, est spatium aperiendum cum. ACERVUS compago creatur) ) sed obiectum initialisatur cum obiectum instantiatur. Essentia conditoris est reponere munus Init munus quod scripsimus in Stack et Date classes ante.

Features constructor:

1. Munus nomen est idem quod genus nominis
2. Nulla reditus pretii est (non opus est pretio reddere aliquid, nec inane scribere. Haec regula C++
3. Cum obiectum instantiatur, ratio automatice conditorem respondentem appellabit.
4. Constructores cumulatur
5. Si constructor explicitus in genere definitus nullus est, C++ compilator automatice defectionem parametri constructoris generabit.

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;
 
};

Constructor parameter, fabricator defalta, et fabricator ab compilator generatus per defaltam cum non scribimus conditorem nominantur omnes conditores default. Sed unum horum trium non simul potest esse. Quamvis constructor parameterless et constructor plenum default constituunt functionem onerandi, erit ambiguitas in vocatione illa.Nota quod non solum defalta constructor generatur per defaltam a compilator, id est constructor, parameter constructor, et constructor plenus defalta etiam defalta constructor.

Non scribimus. Fabrica ab compilator generata per defaltam non requisita ad initializationem in variabilium specierum membri fundamento necessarias habet. Hoc est, utrum initialized sit necne incertum, a compilator pendet.

//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++ genera in rationes consuetudinarias dividit et in typo (typis fundamentalibus) dividit. Typis inaedificata sunt genera notitiarum indigenarum a lingua provisarum, ut int/char/duplum/monstrum, etc. Mores typi sunt typi qui nos definimus utentes keywords sicut genus/struct.Conditor hic automatice initialis factus est, et VS etiam initiales in magnitudine speciei constructas efficit. Diversi compilatores diversi valores initializationes habent, et C ++ non indicat.

Ad consuetudinem generis membrum variabilium, oportet vocare default constructor huius membri variabilis ut illud initializet.Si hoc membrum variabilis defaltam machinator non habet, error nuntiabitur. Si hoc membrum variabile initialize volumus, necesse est ut album initializationem solvat.

Summarium: In pluribus, nosmetipsos fabricatorem efficere oportet. In paucis casibus simile est MyQueue et cum Stack defaltam habet conditorem, MyQueue automatice generari et adhiberi potest.

4.2 Destructor

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

Characteres destructi:

1. destructor nomen praecedit characteribus ~

2. Nulla parametri et nulla reditus pretii (consistent cum conditore)

3. Classis unum solum habere potest destructorem.Si definitio non manifestatur, ratio automatice defaltam destructorem generabit.

4. Obiecto cycli declaratione finito, systema destruentem sponte vocabit.

5. Similis constructor non scribimus destructor ab ipso generante compilator nec processus membra in typo aedificata vocabunt.

6. Sciendum etiam est quod, cum ostendimus destructor, destructor consuetudinis erit etiam membrum genus, quod significat, quod destructor consuetudinis genus membrum sponte vocabitur cuiuscumque rei situs.

//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;
}

Destructor in MyQueue nihil agit, sed C++ quod alii destruentes vocabuntur ad memoriam emittendi.

Si nullae facultates petuntur, destructor scribendus non est, et defectus destructor ab compilator generatus directe adhiberi potest, ut Date ut MyQueue, sed auxilium est application

4.5 Operator obruuntur

• Cum operariorum in obiectis impressis adhibentur, lingua C++ nobis permittit ut novas significationes in forma operantis obruant. C++ stipuletur ut cum genus obiecti genus operantis utatur, converti debet in vocationem ad respondentem operanti onerare.
• Operans onus est munus cum nomine specifico.Sicut alia munera, etiam rationem reditus habet ac album parametri, sicut corpus functionis

 
 
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;
}

• Munus operantis cumulatur tot parametros sumit quot parametri quas operator agit.In unara oneraria solatium unum parametrum habet, et operator binarius duos parametros habet. Sinistra operandi operandi binarii ad primum parametrum transmittitur, et dextra operandi ad alterum parametrum transmittitur.

//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;
}

• Si operantis munus onustum membrum est functio, prima operandi ad hunc monstratorem implicite transmittitur. Ergo, cum operator tamquam membrum munus onustum est, unum minus parametrum habet quam operandi.
• Postquam operator cumulatur, eius praecedentia et societas cohaerentia cum operibus in speciebus aedificatis manent.
• Sexualem operatorem creare non potes per compositus concatenatis quae non sunt in syntaxi: e.g.