指针权限，new与delete，类与对象，函数模板，类模板的用法指针权限用法 new与delete 用法类与对象用法函数模板用法类模板用法

Posted on 2023年10月24日2023年10月24日 by hackdl

指针权限用法

void Print(const 服务器托管网char* SecretPointer)
{
	cout  "绝密指令为：";
	cout  SecretPointer  endl;
}

void Change(int& number, int* const FixedPointer)
{
	cout  "更换站台数字为：";
	cin >> number;
	cout  *FixedPointer  endl;
}

int main()
{
	char* SecretPointer_01 = (char*)malloc(sizeof(char) * 20);
	cout  "请输入绝密指令：";
	cin >> SecretPointer_01;
	const char* SecretPointer = SecretPointer_01;
	Print(SecretPointer);

	int number = 100;
	int* const FixedPointer = &number;
	cout  "原站台数字为："  *FixedPointer  endl;
	Change(number, FixedPointer);

	return 0;
}

new与delete 用法

#include 
using namespace std;

int* CreateSpace1(int*&  PointerOfSum1)
{
	PointerOfSum1 = new int(0);     // 1 
	return new int[5]{ 1,2,3,4,5 };     //  2
}

void AddArray1(int*& PointerOfSum1, int*& PointerOfArray1)
{
	for (int i = 0; i  5; i++)
	{
		(*PointerOfSum1) += (*(PointerOfArray1 + i));
	}
}

// 

class StupidPerson
{
public:
	StupidPerson(int IQ = 10)
		:_IQ(IQ)
	{}
	int GetIQ()
	{
		return _IQ;
	}
private:
	int _IQ;
};

StupidPerson* CreateSpace2(int*& PointerOfSum2)
{
	PointerOfSum2 = new int(0);
	return new StupidPerson[5];    // 3
}

void AddArray2(int*& PointerOfSum2, StupidPerson*& PointerOfArray2)
{
	for (int i = 0; i  5; i++)
	{
		(*PointerOfSum2) += ((*(PointerOfArray2 + i)).GetIQ());
	}
}

//

class SmartPerson
{
public:
	SmartPerson(int IQ = 100)
		:_IQ(IQ)
	{}
	~SmartPerson()
	{
		_IQ = 0;
	}
	int GetIQ()
	{
		return _IQ;
	}
private:
	int _IQ;
};

SmartPerson* CreateSpace3(int*& PointerOfSum3)
{
	PointerOfSum3 = new int(0);
	return new SmartPerson[5]{ SmartPerson(),SmartPerson(101),SmartPerson(102) ,SmartPerson(99) ,SmartPerson(107) };   // 4
}

void AddArray3(int*& PointerOfSum3, SmartPerson*& PointerOfArray3)
{
	for (int i = 0; i  5; i++)
	{
		(*PointerOfSum3) += ((*(PointerOfArray3 + i)).GetIQ());
	}
}

int main()
{
	int* PointerOfSum1 = nullptr;
	int* PointerOfArray1 = CreateSpace1(PointerOfSum1);
	AddArray1(PointerOfSum1, PointerOfArray1);
	cout  "总和为："  (*PointerOfSum1)  endl;
	delete PointerOfSum1;   // 5
	delete[] PointerOfArray1;    //  6
	//
	int* PointerOfSum2 = nullptr;
	StupidPerson* PointerOfArray2 = CreateSpace2(PointerOfSum2);
	AddArray2(PointerOfSum2, PointerOfArray2);
	cout  "IQ总和为："  (*PointerOfSum2)  endl;
	delete PointerOfSum2;
	delete[] PointerOfArray2;
	//
	int* PointerOfSum3 = nullptr;
	SmartPerson* PointerOfArray3 = CreateSpace3(PointerOfSum3);
	AddArray3(PointerOfSum3, PointerOfArray3);
	cout  "IQ总和为："  (*PointerOfSum3)  endl;
	delete PointerOfSum3;
	delete[] PointerOfArray3;
	//
	SmartPerson* ps = (SmartPerson*)malloc(sizeof(SmartPerson) * 10);
	cout  "内存池已经创建完成！"  endl;
	new(ps)SmartPerson(110);    //  7
	new(ps + 1)SmartPerson(103);
	cout  "第一个人智商为："  ps->GetIQ()  endl;
	cout  "第二个人智商为："  (ps + 1)->GetIQ()  endl;
	ps->~SmartPerson();   // 8
	(ps + 1)->~SmartPerson();
	return 0;
}

类与对象用法

test.h

#include 
using namespace std;

class Country
{
	friend class Citizen;
	friend istream& operator>>(istream& cin, Country& country);
	friend ostream& operator(ostream& cout, const Country& country);
public:
	//构造函数
	Country();
	//拷贝构造函数
	Country(const Country& other);
	//析构函数
	~Country();
	//赋值运算符重载
	Country& operator=(const Country& other);
private:
	char* _countryname;
	char* _capital;
};
//流插入运算符重载
istream& operator>>(istream& cin, Country& country);
//流提取运算符重载
ostream& operator(ostream& cout, const Country& country);

//

class Citizen
{
	friend int operator>(const Citizen& c1, const Citizen& c2);
	friend istream& operator>>(istream& cin, Citizen& citizen);
	friend ostream& operator(ostream& cout, const Citizen& citizen);
public:
	//构造函数
	explicit Citizen(bool iscriminal = false);
	//拷贝构造函数
	Citizen(const Citizen& other);
	//析构函数
	~Citizen();
	//赋值运算符重载
	Citizen& operator=(const Citizen& other);
	//前置++运算符重载
	Citizen& operator++();
	//后置++运算符重载
	Citizen operator++(int);
	//普通运算符重载
	Citizen& operator-(int num);
	//静态成员函数
	static int GetTotalCitizen();
	//友元类的跨类访问
	void GetCountry();
private:
	//成员变量
	char* _personalname;
	int _age;
	Country _nationality;
	bool _iscriminal;
	int _creditscore;
	const int _maxcreditscore;
	//类的静态区成员变量
	static int _totalcitizen;
};
//普通运算符重载
int operator>(const Citizen& c1, const Citizen& c2);
//流插入运算符重载
istream& operator>>(istream& cin, Citizen& citizen);
//流提取运算符重载
ostream& operator(ostream& cout, const Citizen& citizen);

//func.cpp

#include "test.h"

//Country类相关
Country::Country()
{
	_countryname = new char[20]{ '' };
	_capital = new char[20]{ '' };
}

Country::Country(const Country& other)
{
	_countryname = new char[20]{ '' };
	_capital = new char[20]{ '' };
	memcpy(_countryname, other._countryname, sizeof(char) * 20);
	memcpy(_capital, other._capital, sizeof(char) * 20);
}

Country::~Country()
{
	delete[] _countryname;
	delete[] _capital;
}

Country& Country::operator=(const Country& other)
{
	if (&other != this)
	{
		memcpy(_countryname, other._countryname, sizeof(char) * 20);
		memcpy(_capital, other._capital, sizeof(char) * 20);
	}
	return *this;
}

istream& operator>>(istream& cin, Country& country)
{
	cin >> country._countryname >> country._capital;
	return cin;
}

ostream& operator(ostream& cout, const Country& country)
{
	cout  country._countryname  " "  country._capital;
	return cout;
}


//Citizen类相关
Citizen::Citizen(bool iscriminal)
	:_age(0)
	,_nationality()
	,_iscriminal(iscriminal)
	,_creditscore(0)
	,_maxcreditscore(100)
{
	_personalname = new char[20]{ '' };
	_totalcitizen++;
}

Citizen::Citizen(const Citizen& other)
	:_age(other._age)
	, _nationality(other._nationality)
	, _iscriminal(other._iscriminal)
	, _creditscore(other._creditscore)
	, _maxcreditscore(other._maxcreditscore)
{
	_personalname = new char[20]{ '' };
	memcpy(_personalname, other._personalname, sizeof(char) * 20);
	_totalcitizen++;
}

Citizen::~Citizen()
{
	delete[] _personalname;
	_totalcitizen--;
}

Citizen& Citizen::operator=(const Citizen& other)
{
	if (&other != this)
	{
		_age = other._age;
		_nationality = other._nationality;
		_iscriminal = other._iscriminal;
		_creditscore = other._creditscore;
		memcpy(_personalname, other._personalname, sizeof(char) * 20);
	}
	return *this;
}

Citizen& Citizen::operator++()
{
	if (_creditscore  _maxcreditscore)
	{
		_creditscore++;
	}
	return *this;
}

Citizen Citizen::operator++(int)
{
	Citizen tmp(*this);
	if (_creditscore  _maxcreditscore)
	{
		_creditscore++;
	}
	return tmp;
}

Citizen& Citizen::operator-(int num)
{
	if (_creditscore > 0)
	{
		_creditscore -= num;
		if (_creditscore  0)
		{
			_creditscore = 0;
		}
	}
	return *this;
}

int operator>(const Citizen& c1, const Citizen& c2)
{
	if (c1._creditscore > c2._creditscore)
	{
		return 1;
	}
	else if (c1._creditscore  c2._creditscore)
	{
		return 2;
	}
	else
	{
		return 0;
	}
}

istream& operator>>(istream& cin, Citizen& citizen)
{
	cin >> citizen._personalname >> citizen._age >> citizen._nationality
		>> citizen._iscriminal >> citizen._creditscore;
	return cin;
}

ostream& operator(ostream& cout, const Citizen& citizen)
{
	cout  citizen._personalname  " "  citizen._age  " "  citizen._nationality
		 " "  citizen._iscriminal  " "  citizen._creditscore;
	return cout;
}

int Citizen::GetTotalCitizen()
{
	return _totalcitizen;
}

void Citizen::GetCountry()
{
	cout  _nationality._countryname  " "  _nationality._capital  endl;
}

//类的静态区成员变量定义
int Citizen::_totalcitizen = 0;

//test.cpp

#include "test.h"

int main()
{
	Citizen Shen(0);
	cin >> Shen;
	cout  Shen  endl;

	Citizen Jun(Shen);
	cout  Jun  endl;

	Citizen Elon(0);
	cin >> Elon;
	cout  Elon  endl;

	cout  "此时人数："  Citizen::GetTotalCitizen()  endl;
	return 0;
}

函数模板用法

// test.h

#include 
using namespace std;

template typename T>
void Swap(T& a, T& b)
{
	T tmp = a;
	a = b;
	b = tmp;
}

template typename T1, typename T2, typename T3>
void Print(const T1& a, const T2& b, const T3& c)
{
	cout  a  " "  b  " "  c  endl;
}

// test.cpp
#include "test.h"

int mai服务器托管网n()
{
	int x = 1;
	int y = 2;
	char m = 'x';
	char n = 'y';
	cout  "交换前："  endl;
	cout  x  " "  y  endl;
	cout  m  " "  n  endl;
	Swap(x, y);
	Swap(m, n);
	cout  "交换后："  endl;
	cout  x  " "  y  endl;
	cout  m  " "  n  endl;
	//
	const char* pointer = "根据ASCII码表对应的(值/字符)为";
	char obj1 = 'A';
	int obj2 = 65;
	Print(obj1, pointer, obj2);
	Printint, const char*, char>(obj1, pointer, obj2);     
	return 0;
}

类模板用法

// test.h
#include 
using namespace std;

template typename T>
class Person
{
	friend istream& operator>>(istream& cin, PersonT>& person)
	{
		cin >> person._name >> *(person._luckysymbol);
		return cin;
	}
	friend ostream& operator(ostream& cout, PersonT>& person)
	{
		cout  person._name  " "  *(person._luckysymbol);
		return cout;
	}
public:
	Person();
	Person(const Person& other);
	~Person();
	Person& operator=(const Person& other);
private:
	char* _name;
	T* _luckysymbol;
};


template typename T>
PersonT>::Person()
{
	_name = new char[20]{ 0 };
	_luckysymbol = new T(0);
}

template typename T>
PersonT>::Person(const Person& other)
	:_name(new char[20]{ 0 })
	, _luckysymbol(new T(0))
{
	memcpy(_name, other._name, sizeof(char) * 20);
	*_luckysymbol = *(other._luckysymbol);
}

template typename T>
PersonT>::~Person()
{
	delete _luckysymbol;
	delete[] _name;
}

template typename T>
PersonT>& PersonT>::operator=(const Person& other)
{
	if (&other != this)
	{
		memcpy(_name, other._name, sizeof(char) * 20);
		*_luckysymbol = *(other._luckysymbol);
	}
	return  *this;
}

// test.cpp
#include "test.h"

int main()
{
	Personint> Shen;
	Personchar> Hu;
	Persondouble> Ye;
	cin >> Shen >> Hu >> Ye;
	Personint> Junyang(Shen);  
	Personchar> Yao;   
	Yao = Hu;   
	cout  Shen  endl;
	cout  Hu  endl;
	cout  Ye  endl;
	cout  Junyang  endl;
	cout  Yao  endl;
	return 0;
}

服务器托管，北京服务器托管，服务器租用 http://www.fwqtg.net

相关推荐: oracle新建库(表空间)表
前言
一、sqlplus登录
二、表空间
三、创建新用户并指定表空间
四、使用新用户
五、使用图形化工具连接(Navicat)
六、新建表
总结

文章目录前言一、sqlplus登录二、表空间 1.新建表空间 2. 查看表空间 3. 查看表空间和对应数据文件 4.表空间增加数据文件 5.删除单个数据文件（只有一个默认的会删除失败） 6.删除表空间及数据文件(慎用) 三、创建新用户并指定表空间 1.去…

服务器托管，北京服务器托管，服务器租用，机房机柜带宽租用

服务器托管

咨询：董先生

电话13051898268 QQ/微信93663045！

上一篇: Experience Design 2022「XD原型设计软件」中文直装汉化版下载
下一篇: OpenAI （ChatGPT）无需代码连接明道云应用的方法