C++ 类和对象笔记之模板

最新推荐文章于 2024-10-28 21:09:56 发布
最新推荐文章于 2024-10-28 21:09:56 发布
阅读量177 收藏
点赞数 1
分类专栏： 杂项 文章标签： 模板 c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lianghudream/article/details/117359197
版权

C++ 类和对象笔记之模板


c++提供了函数模板(function template.)所谓函数模板，实际上是建立一个通用函数，其函数类型和形参类型不具体制定，用一个虚拟的类型来代表。这个通用函数就成为函数模板。凡是函数体相同的函数都可以用这个模板代替，不必定义多个函数，只需在模板中定义一次即可。在调用函数时系统会根据实参的类型来取代模板中的虚拟类型，从而实现不同函数的功能。

  • c++提供两种模板机制:函数模板和类模板
  • 类属 - 类型参数化，又称参数模板

1 函数模板

  • 泛型编程 – 模板技术 特点：类型参数化
  • template< typename T > 告诉编译器后面紧跟着的函数或者类中出现T，不会报错，T是一个通用的数据类型
  • 实现通用两个数进行交换函数，使用
    自动类型推导 必须要推导出一致的T才可以使用
    显示指定类型 mySwap < int >(a,b);
#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
#include <cstdio>
#include <string>
#include <cstdlib>
#include <cmath>
#include <ctime>
#include<vector>
#include<string>
#include<queue>
#include<stack>
#include<memory>
using namespace std;
void mySwapInt(int &a, int &b)
{
	int temp = a;
	a = b;
	b = temp;
}
void mySwapDouble(double &a, double &b)
{
	double temp = a;
	a = b;
	b = temp;
}
//利用模板实现通用交换函数
template<typename T>//T代表有一个通用得数据类型,告诉编译器如果下面紧跟着的函数或者类中出现T不要报错,class 和 typename都是一样的

void mySwap(T &a, T &b) 
{
	T temp = a;
	a = b;
	b = temp;
}
//模板不能单独使用，必须指定出T才可以使用
template<typename T>
void mySwap2()
{
	
}
void test01() {
	int a = 10;
	int b = 20;
	//1、自动类型推到，必须推导出一致的T数据类型,才可以正常使用模板
	//推导不出一致的T，因此无法调用
	//mySwapInt(a, b);
	//char c1 = 'c';
	mySwap(a, b);
	cout << a << endl;
	cout << b << endl;
	//mySwap<int>(a, c1);
	//cout << a << endl;
	//cout << c1 << endl;
	double c = 3.14;
	double d = 1.1;
	
	//mySwapDouble(c, d);
	//2、显示指定类型
	mySwap<int>(a, b);
	mySwap2<int>();//必须告诉编译器T类型才可以调用
	mySwap(c, d);
	cout << c << endl;
	cout << d << endl;
	
}
int main(void)
{
	test01();
	system("pause");
	return EXIT_SUCCESS;
}

在这里插入图片描述
   用模板是为了实现泛型，可以减轻编程的工作量，增强函数的重用性。

2 函数模板与普通函数的区别

函数模板和普通函数的区别以及调用规则。
区别：

  • 函数模板：如果使用自动类型推导，是不可以发生隐式类型转换的。

  • 普通函数： 可以发生隐式类型转换。
    调用规则

  • 如果函数模板和普通函数都可以调用，那么优先调用普通函数。

  • 如果想强制调用函数模板，可以使用空模板参数列表。
    myPrint<>(a, b);

  • 函数模板也可以发生函数重载。如果函数模板能产生更好的匹配，那么优先使用函数模板
    模板的实现机制

  • 编译器并不是把函数模板处理成能够处理任何类型的函数。

  • 函数模板通过具体类型产生不同的函数 — 通过函数模板产生的函数称为模板函数。

  • 编译器会对函数模板进行两次编译，在声明的地方对模板代码本身进行编译，在调用的地方对参数替换后的代码进行编译。

#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
using namespace std;

//1、函数模板和普通函数的区别
template<class T>
T myAdd(T a, T b)
{
	return a + b;
}

int myAdd2(int a, int b)
{
	return a + b;
}
void test01()
{
	int a = 10;
	int b = 20;
	char c = 'c';
	//myAdd(a, c); //如果使用自动类型推导，是不可以发生隐式类型转换的

	cout << myAdd2(a, c) << endl; //普通函数 可以发生隐式类型转换
}


//2、函数模板和普通函数的调用规则
template<class T>
void myPrint(T a, T b)
{
	cout << "函数模板调用" << endl;
}

/*
函数模板通过具体类型产生不同的函数  --- 通过函数模板产生的函数  称为 模板函数
void myPrint(int a ,int b)
{
cout << "函数模板调用" << endl;
}

void myPrint(double a ,double b)
{
cout << "函数模板调用" << endl;
}
*/

template<class T>
void myPrint(T a, T b, T c)
{
	cout << "函数模板(T a, T b ,T c)调用" << endl;
}

void myPrint(int a, int b)
{
	cout << "普通函数调用" << endl;
}



void test02()
{
	//1、如果函数模板和普通函数都可以调用，那么优先调用普通函数
	int a = 10;
	int b = 20;
	//myPrint(a, b);

	//2、如果想强制调用函数模板，可以使用空模板参数列表
	myPrint<>(a, b);

	//3、函数模板也可以发生函数重载
	myPrint(a, b, 10);

	//4、如果函数模板能产生更好的匹配，那么优先使用函数模板
	char c = 'c';
	char d = 'd';
	myPrint(c, d);

}

int main() {

	//test01();

	test02();

	system("pause");
	return EXIT_SUCCESS;
}

4模板局限性

4.1模板的实现机制

  • 编译器并不是把函数模板处理成能够处理任何类型的函数
  • 函数模板通过具体类型产生不同的函数 — 通过函数模板产生的函数 称为模板函数。
  • 编译器会对函数模板进行两次编译，在声明的地方对模板代码本身进行编译，在调用的地方对参数替换后的代码进行编译。

4.2 模板局限性

  • 模板并不是真实的通用，对于自定义数据类型，可以使用具体化技术，实现对自定义数据类型特殊使用
  • template<> bool myCompare(Person &a, Person &b)
#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
using namespace std;
#include <string>
class Person
{
public:
	Person(string name, int age)
	{
		this->m_Name = name;
		this->m_Age = age;
	}
	string m_Name;
	int m_Age;

};

//显示两个变量 对比 函数
template<class T>
bool myCompare(T &a, T&b)
{
	if (a == b)
	{
		return true;
	}
	return false;
}

//利用具体化技术,实现对自定义数据类型提供特殊模板
template<> bool myCompare(Person &a, Person &b)
{
	if (a.m_Name == b.m_Name && a.m_Age == b.m_Age)
	{
		return true;
	}
	return false;
}

void test01()
{
	int a = 10;
	int b = 10;

	bool ret1 = myCompare(a, b);

	if (ret1 )
	{
		cout << "a == b" << endl;
	}
	else
	{
		cout << "a != b" << endl;
	}

	Person p1("Tom", 19);
	Person p2("Tom", 20);

	bool ret = myCompare(p1, p2);
	if (ret)
	{
		cout << "p1 == p2" << endl;
	}
	else
	{
		cout << "p1 != p2" << endl;
	}
}

int main() {

	test01();

	system("pause");
	return EXIT_SUCCESS;
}

在这里插入图片描述

5 类模板

类模板和函数模板区别：

  • 类模板不可以使用自动类型推导，只能用显示指定类型
  • 类模板中 可以有默认参数
#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
using namespace std;
#include <string>
template<class NAMETYPE, class AGETYPE = int > //类模板中 可以有默认参数
class Person
{
public:
	Person(NAMETYPE name, AGETYPE age)
	{
		this->m_Name = name;
		this->m_Age = age;
	}

	void showPerson()
	{
		cout << "姓名： " << this->m_Name << " 年龄： " << this->m_Age << endl;
	}
	NAMETYPE m_Name;
	AGETYPE m_Age;
};

void test01()
{

	//类模板和函数模板区别：
	//1、类模板不可以使用自动类型推导，只能用显示指定类型
	//2、类模板中 可以有默认参数
	//Person p1("孙悟空", 100);

	Person<string > p1("孙悟空", 100);
	p1.showPerson();
}

int main() {

	test01();

	system("pause");
	return EXIT_SUCCESS;
}

6 类模板中成员函数创建时机

类模板中的成员函数并不是一开始创建的，而是在运行阶段确定出T的数据类型才去创建

#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
#include <cstdio>
#include <string>
#include <cstdlib>
#include <cmath>
#include <ctime>
#include<vector>
#include<string>
#include<queue>
#include<stack>
#include<numeric>
#include<unordered_map>
#include<memory>
using namespace std;
class Person1
{
public:
	void showPerson1() 
	{
		cout << "Person1 show 调用" << endl;
	}
};
class Person2 
{
public:
	void showPerson2()
	{
		cout << "Person2 show调用" << endl;
	}
};
//类模板中的成员函数 并不是一开始创建的，而是在运行阶段确定出T的数据类型才去创建
template<class T>
class MyClass
{
public:
	void func1() 
	{
		obj.showPerson1();
	}
	void func2() 
	{
		obj.showPerson2();
	}
	T obj;
};
void test01()
{
	MyClass<Person1> p1;
	p1.func1();
	//p1.func2();
}
int main(void)
{
	test01();
	system("pause");
	return EXIT_SUCCESS;
}

7 类模板做函数参数

类模板做函数参数

  • 指定传入类型
    void doWork(Person <string, int>&p)
  • 参数模板化
    template<class T1, class T2>
    void doWork2(Person <T1, T2>&p)
  • 整个类模板化
    template < class T > void doWork3( T &p)
  • 查看T数据类型
    typeid(T).name()
#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
using namespace std;
#include <string>
template<class T1, class T2> //类模板中 可以有默认参数
class Person
{
public:
	Person(T1 name, T2 age)
	{
		this->m_Name = name;
		this->m_Age = age;
	}
	void showPerson()
	{
		cout << "姓名： " << this->m_Name << " 年龄： " << this->m_Age << endl;
	}
	T1 m_Name;
	T2 m_Age;
};
//1、指定传入类型
void doWork(Person <string, int>&p)
{
	p.showPerson();
}
void test01()
{
	Person <string, int>p("孙悟空", 999);
	doWork(p);
}
//2、参数模板化
template<class T1, class T2>
void doWork2(Person <T1, T2>&p)
{
	cout << "T1数据类型： " << typeid(T1).name() << endl;
	cout << "T2数据类型： " << typeid(T2).name() << endl;
	p.showPerson();
}
void test02()
{
	Person<string, int>p("猪八戒", 998);
	doWork2(p);
}
//3、整个类 模板化
template<class T>
void doWork3(T &p)
{
	cout << "T的数据类型： " << typeid(T).name() << endl;
	p.showPerson();
}

void test03()
{
	Person<string, int>p("唐僧", 10000);
	doWork3(p);
}

int main() {
	test01();
	test02();
	test03();
	system("pause");
	return EXIT_SUCCESS;
}

运行结果

8 类模板碰到继承的问题以及解决

  • 必须要指定出父类中的T数据类型，才能给子类分配内存
  • template<class T1 ,class T2>
  • class Son2 :public Base2 <T2 >
#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
using namespace std;
template<class T>
class Base
{
public:
	T m_A;
};
//必须要指定出父类中的T数据类型，才能给子类分配内存
class Son :public Base<int>
{
};
template<class T>
class Base2
{
public:
	T m_A;
};
template<class T1, class T2>
class Son2 :public Base2<T2>
{
public:
	Son2()
	{
		cout << typeid(T1).name() << endl;
		cout << typeid(T2).name() << endl;
	}
	T1 m_B;
};
void test01()
{
	Son2 <int, double> s;
}
int main() {
	test01();
	system("pause");
	return EXIT_SUCCESS;
}

![运行结果](https://img-blog.csdnimg.cn/20210531203204507.png)

9 类模板中的成员函数类外实现

  • void Person<T1, T2>::showPerson()
#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
#include <cstdio>
#include <string>
#include <cstdlib>
#include <cmath>
#include <ctime>
#include<vector>
#include<string>
#include<queue>
#include<stack>
#include<numeric>
#include<unordered_map>
#include<memory>
using namespace std;
template<class T1,class T2>
class Person 
{
public:
	Person(T1 name, T2 age);
	/*{
		this->m_Name = name;
		this->m_Age = age;
	}*/
	void showPerson();
	/*{
		cout << "姓名：" << this->m_Name << "年龄：" << this->m_Age << endl;
	}*/
	T1 m_Name;
	T2 m_Age;
};
template<class T1,class T2>
Person<T1, T2>::Person(T1 name, T2 age)
{
	this->m_Name = name;
	this->m_Age = age;
}
template<class T1, class T2>
void Person<T1, T2>::showPerson() 
{
	cout << "姓名：" << this->m_Name << "年龄：" << this->m_Age << endl;
}
void test01() 
{
	Person<string, int> p("Tom", 10);
	p.showPerson();
}
int main(void)
{
	test01();
	system("pause");
	return EXIT_SUCCESS;
}

运行结果

10 类模板的分文件编写问题以及解决

类模板中的成员函数，不会一开始创建，因此导致分文件编写时连接不到函数的实现，出现无法解析的外部命令错误。

  • 解决方式1：
    直接包含.cpp文件 （不推荐）。
  • 解决方式2：
    将类声明和实现写到同一个文件中，将文件的后缀名改为 .hpp 即可。
  • 代码

person.hpp

#pragma once
#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
using namespace std;
template<class T1, class T2>
class Person
{
public:
	Person(T1 name, T2 age);
	void showPerson();
	T1 m_Name;
	T2 m_Age;
};
template<class T1, class T2>
Person<T1, T2>::Person(T1 name, T2 age)
{
	this->m_Name = name;
	this->m_Age = age;
}

template<class T1, class T2>
void Person<T1, T2>::showPerson()
{
	cout << "姓名： " << this->m_Name << " 年龄：" << this->m_Age << endl;
}

test.cpp

#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
using namespace std;
#include "person.hpp"
#include <string>

void test01()
{
	Person<string, int> P("Jerry", 20);
	P.showPerson();
}


int main() {

	test01();


	system("pause");
	return EXIT_SUCCESS;
}

在这里插入图片描述

11 类模板碰到友元函数

  • 友元类内实现
    friend void printPerson(Person<T1, T2> &p)
  • 友元类外实现
    声明：
      friend void printPerson2<>(Person<T1, T2> &p);
    实现：
      template<class T1,class T2>
      void printPerson2(Person<T1, T2> &p){ 。。。}
      template<class T1,class T2>
      class Person;
      template<class T1,class T2>
      void printPerson2(Person<T1, T2> &p);
#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
#include <cstdio>
#include <string>
#include <cstdlib>
#include <cmath>
#include <ctime>
#include<vector>
#include<string>
#include<queue>
#include<stack>
#include<numeric>
#include<unordered_map>
#include<memory>
using namespace std;
template<class T1,class T2>
class Person;
template<class T1,class T2>
void printPerson3(Person<T1, T2>&p) 
{
	cout << "类外实现---姓名：" << p.m_Name << "年龄：" << p.m_Age << endl;
}
template<class T1,class T2>
class Person 
{
	//1、友元函数 类内实现
	friend void printPerson(Person<T1, T2>&p)
	{
		cout << "姓名：" << p.m_Name << "年龄：" << p.m_Age << endl;
	}
	//2、友元函数 类外实现
	friend void printPerson2<>(Person<T1, T2>&p);
	friend void printPerson3<>(Person<T1, T2>&p);
public:
	Person(T1 name, T2 age)
	{
		this->m_Name = name;
		this->m_Age = age;
	}
private:
	T1 m_Name;
	T2 m_Age;
};
template<class T1,class T2>
void printPerson2(Person<T1, T2>&p)
{
	cout << "类外实现---姓名:" << p.m_Age << "年龄：" << p.m_Age << endl;
}
void test01() 
{
	Person<string, int>p("Tom", 100);
	printPerson(p);
	printPerson2(p);
	printPerson3(p);
}
int main(void)
{
	test01();
	system("pause");
	return EXIT_SUCCESS;
}

在这里插入图片描述

12 类模板的应用

设计一个数组模板类(MyArray),完成对不同类型元素的管理。
代码如下
myArray.hpp

#pragma  once 
#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
using namespace std;

template<class T>
class MyArray
{
public:
	//MyArray(){};

	//有参构造
	MyArray(int capacity)
	{
		this->m_Capacity = capacity;
		this->m_Size = 0;
		this->pAddress = new T[this->m_Capacity];
	}

	//拷贝构造
	MyArray(const MyArray & arr)
	{
		this->m_Capacity = arr.m_Capacity;
		this->m_Size = arr.m_Size;
		this->pAddress = new T[this->m_Capacity];
		for (int i = 0; i < arr.m_Size; i++)
		{
			this->pAddress[i] = arr.pAddress[i];
		}
	}

	//重载=   
	MyArray& operator=(const MyArray & arr)
	{
		if (this->pAddress)
		{
			delete[] this->pAddress;
			this->pAddress = NULL;
		}

		this->m_Capacity = arr.m_Capacity;
		this->m_Size = arr.m_Size;
		this->pAddress = new T[this->m_Capacity];
		for (int i = 0; i < arr.m_Size; i++)
		{
			this->pAddress[i] = arr.pAddress[i];
		}
		return *this;
	}


	//重载[] 
	T& operator[] (int index)
	{
		return this->pAddress[index];
	}

	//尾插法
	void pushBack(const T&val)
	{
		if (this->m_Capacity == this->m_Size)
		{
			return;
		}
		this->pAddress[this->m_Size] = val;
		this->m_Size++;
	}

	//获取数组容量
	int getCapacity()
	{
		return this->m_Capacity;
	}

	//获取数组大小
	int getSize()
	{
		return this->m_Size;
	}

	//析构
	~MyArray()
	{
		if (this->pAddress)
		{
			delete[] this->pAddress;
			this->pAddress = NULL;
		}
	}

private:
	T * pAddress; //指向堆区真实数组指针

	int m_Capacity; //数组容量

	int m_Size;  //数组大小

};

test.cpp

#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
using namespace std;
#include "myArray.hpp"
#include <string>

class Person
{
public:
	Person() {};
	Person(string name, int age)
	{
		this->m_Name = name;
		this->m_Age = age;
	}

	string m_Name;
	int m_Age;
};

void myPrintInt(MyArray <int> &myIntArr)
{

	for (int i = 0; i < myIntArr.getSize(); i++)
	{
		cout << myIntArr[i] << endl;
	}
}

void test01()
{
	MyArray <int> myIntArr(100);
	for (int i = 0; i < 10; i++)
	{
		myIntArr.pushBack(i + 100);
	}
	myPrintInt(myIntArr);
}

void myPrintPerson(MyArray<Person> &myPersonArr)
{
	for (int i = 0; i < myPersonArr.getSize(); i++)
	{
		cout << "姓名： " << myPersonArr[i].m_Name << " 年龄：" << myPersonArr[i].m_Age << endl;
	}
}

void test02()
{
	MyArray<Person> myPersonArr(100);
	Person p1("孙悟空", 1000);
	Person p2("猪八戒", 800);
	Person p3("唐僧", 500);
	Person p4("沙悟净", 300);
	Person p5("白龙马", 10000);

	myPersonArr.pushBack(p1);
	myPersonArr.pushBack(p2);
	myPersonArr.pushBack(p3);
	myPersonArr.pushBack(p4);
	myPersonArr.pushBack(p5);

	myPrintPerson(myPersonArr);

	cout << "数组容量： " << myPersonArr.getCapacity() << endl;
	cout << "数组大小： " << myPersonArr.getSize() << endl;
}

int main() {

	//test01();
	test02();

	system("pause");
	return EXIT_SUCCESS;
}

在这里插入图片描述

郭涤生
关注
专栏目录
C++提高部分_C++类模板对象做函数参数---C++语言工作笔记090
添柴程序猿的专栏
06-28 237
然后我们再去看C++的类模板也可以做函数的参数,而且参数方式 可以有3种方式,1.可以指定传入类型,2可以把参数变成模板进行传递, 3.将整个类进行模板化 我们去写个例子去看看 首先我们写一个Person类 给出两个属性m_Name m_Age 这个类是个类模板. 指定了两个class类型 T1,T2 然后我们给这个类写一个构造方法,传入T1,T2类型的参数 然后我们再去写一个showPerson()方法,显示内容 然后我们调用的时候,在test01方法中,就可以指..
C++:对象，类和模板
contest_away的博客
12-09 945
类关键字 类名函数方法区成员属性区类的定义就是对象类型的定义 ，在C语言中结构体也是类型的定义，因为C++在某些场景下会调用C库，所以可在C++中使用结构体语法，然而值得注意的区别：1.类名就是类型名类型短（只在C语言中是需要typedef重命名的）2.类中可以定义函数，声明函数不同类的属性不同，函数方法间可重载——成员函数名不用加前缀名同一个类内，不要传对象地址——成员函数函数首个形参为this指针，可以隐式传参类struct class ：机构体strut类结构体。
C++类和对象的模板
u010265211的专栏
06-05 1113
在程序设计中往往尊在这样的两种情况，一种是两个或duo
使用C++模板技术实现类的动态注册和获取
michael780514的专栏
04-10 1317
最近在做一些项目的时候，经常需要用到类的动态注册和获取，使得调用者可以根据名字创建一个类的实例，然后调用改类的虚函数完成功能调用，类似于建立一套数据库访问套件，可以做到后期增加何种数据库访问的无需修改原有代码，需要做的仅仅是按照一定的规范创建一个新类，该类会完成自身的注册，调用者根据名字获取改类实例即可，涉及到的技术包括模板、singletons、object factory方，下面将涉及到的类列
C++面向对象（模板）学习笔记
qq_61179907的博客
02-22 569
c++类和函数模板
常用的C++面向对象编程模板
weixin_43684773的博客
09-10 421
目录1. 一些基础的规则2. 日期类2.1 日期类头文件2.2 日期类执行文件3. 书籍销售类3.1 书籍销售类头文件3.2 书籍销售类执行文件4. 指针类4.1 指针类1头文件4.2 指针类2头文件5. string类5.1 string类1头文件5.2 string类1执行文件5.3 string类2头文件5.4 string类2执行文件6. Account类6.1 Account类执行文件 —— 拥有静态成员7. StrVec类7.1 StrVec类头文件7.2 StrVec类执行文件8. Quote
C++——详解类模板与友元函数
阿标de杂货铺
06-24 2851
模板类的友元函数有三类： 1）非模板友元函数：友元函数不是模板函数，而是利用模板类参数生成的函数。2）约束模板友元函数：模板类实例化时，每个实例化的类对应一个友元函数。 3）非约束模板友元函数：模板类实例化时，如果实例化了n个类，也会实例化n个友元函数，每个实例化的类都拥有n个友元函数。
千锋C++笔记.zip
08-18
包括函数模板和类模板。 9. **异常处理**：C++的异常处理机制允许程序在出现错误时抛出异常，并在适当的地方捕获并处理异常，提高了程序的健壮性。 10. **STL（Standard Template Library）**：STL是C++的标准库，...
cpp代码-c++学习笔记——类与对象
07-14
类是创建对象的模板，它描述了对象应有的行为和状态。例如，你可以创建一个名为“汽车”的类，其中包含属性如品牌、颜色和速度，以及方法如启动、加速和刹车。 在`main.cpp`文件中，我们可能看到了类的定义和对象的...
C语言和C++Builder学习笔记.rar_C++笔记_c++学习笔记_c/C++_学习笔记_编程语言
09-20
1. **面向对象编程**：类、对象、继承、封装和多态是C++的核心，理解这些概念及其在C++Builder中的应用。 2. **构造函数与析构函数**：用于对象的创建和销毁，管理对象生命周期。 3. **虚函数与纯虚函数**：实现多...
c++，可调用对象的统一管理，function类模板
ganfanren00001的博客
11-28 326
c++，可调用对象的统一管理，function类模板： 翻译： 统一管理的意思，就是需要将一堆拥有某个或某些共同属性的对象放到一个容器中，方便日后的调用，因此可调用对象的统一管理的意思，就是要把可调用对象放在一个容器中。 之前讲过可调用对象分为函数指针，仿函数（重载了调用运算符的类），lambda表达式，但lambda表达式本身随写随用，少有用函数指针调用的情况，故只谈函数指针和仿函数的统一管理。 函数指针的写法： int (*func1)(int,int); 仿函数的写法： class Func { p
C++ 类模板概念与实例，模板参数问题
master-dragon的专栏
12-18 7859
什么是类模板？ 一个类模板（也称为类属类或类生成类）允许用户为类定义一种模式，使得类中的某些数据成员、默写成员函数的参数、某些成员函数的返回值，能够取任意类型（包括系统预定义的和用户自定义的）。 如果一个类中数据成员的数据类型不能确定，或者是某个成员函数的参数或返回值的类型不能确定，就必须将此类声明为模板，它的存在不是代表一个具体的、实际的类，而是代表着一类类。类模板中的成员函数全部都是模板函
C++：调用模板基类的成员
风静如云的博客
07-17 719
此三种方式均能让编译成功编译。
模板类继承中关于成员的二阶段查找过程
qq_34988341的博客
06-21 213
1.Parsing of a template. This phase occurs when a template definition is first seen by a compiler (point of definition [3]). During this phase, the lookup is completed only for nondependent names. 2.Template instantiation. It happens when a template is i.
c++中template 模板函数的用法（基础）
nihao_2014的博客
01-08 1436
参考：C++ Template 基础篇（一）：函数模板_lezardfu的专栏-CSDN博客_模板函数 参考：c++中template的用法_zhong29的博客-CSDN博客_c++ template用法 目录 1. 为什么要有泛型编程 2. 函数模板定义 2.1 普通函数模板 2.2 成员函数模板 2.3 为什么成员函数模板不能是虚函数(virtual)？ 3. 实参推断 3.1 如何使用 3.2 当返回值类型也是参数时 3.3 实参推断时的自动类型转换 4.0 函数模板重载..
c++新特性之模板 对象
qq_62309585的博客
09-05 1311
c++新特性关于模板
C++ 类模板对象传参方式
CodeHouse的博客
08-17 2111
#include <iostream> #include <string> using namespace std; /************************************************************************/ /* 类模板对象作为函数参数 1.指定传入的类型-显示指定对象的数据类型 2.参数模板化-将类对象中的参数作为模板进行传递 3.整个类模板化-将对象类型模板化进行传递
《C++显式类型转换：解析多种转换方式的奥秘》
xy520521的博客
10-27 689
当我们从一个存储 Shape 指针的容器中取出指针并希望将其转换为具体的派生类指针以调用特定的绘制方法时，动态_cast可以确保转换的安全性，避免在对象类型不匹配时出现错误。需要注意的是，使用 const_cast修改一个原本被定义为 const 的对象可能会导致未定义的行为，因为这违反了 const 的语义。例如，当我们有一个 const 引用指向一个对象，但在某个特定的函数内部，我们知道这个函数不会修改对象的值，但需要将其传递给一个非 const 版本的函数时，可以使用 const_cast。
「C/C++」C/C++标准库之#include＜cstdlib＞通用工具库
最新发布
何曾参静谧的博客
10-28 566
是C++标准库中的一个头文件，它提供了各种通用工具函数，这些函数最初来源于C标准库中的，并在C++中进行了标准化和扩展。在C++编程中，头文件具有重要地位，它涵盖了字符串转换、类型转换、随机数生成、内存管理和系统调用等多个方面的功能。通过这些实例，我们可以看到头文件在C++编程中的广泛应用。它提供了一系列功能强大的函数，使得开发者能够方便地处理字符串转换、随机数生成、内存管理等任务。在实际开发中，合理利用这些函数可以大大提高编程效率和代码质量。
C++学习笔记：类与对象概述
"C++学习笔记，面向对象程序设计，C++之父比雅尼·斯特劳斯特鲁普，课程性质，课时安排，作业考核，C++的特点与历史，行业地位，应用领域" 在深入探讨类与对象的概念之前，我们先来理解C++的基本概述。C++是由比...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值