运行在VS2022,内容如下。
目录
指定初始化可以在初始化某个成员时跳过其他成员,从而提供更灵活的初始化方式。
将构造函数设为私有,防止外部直接创建对象,并且删除拷贝构造函数和赋值运算符。提供一个公共的静态成员函数来获取唯一实例。使用静态局部变量确保只初始化一次。
模板元编程利用C++模板编译器的优势在编译时计算数值,可以节省运行时的性能。
概念可以用于对模板参数进行约束和限制。在编译时对泛型代码进行更严格的类型检查,提高代码的可读性和可维护性(#include)。
8.C++20指定初始化
指定初始化可以在初始化某个成员时跳过其他成员,从而提供更灵活的初始化方式。
【注意】指定初始化仅适用于结构体和类的成员初始化。
【注意】初始化顺序要和声明顺序匹配,否则报错。
#include<iostream>
using namespace std;
struct Point {
int x;
int y;
int z;
};
int main()
{
Point p1 = { .x = 1, .z = 3 , };
cout << p1.x << ", " << p1.y << ", " << p1.z << endl;
return 0;
}
9.模板函数不能用特定类型编译时
使用模板偏特化来创建模板重载。
#include<iostream>
using namespace std;
class MyClass
{
private:
int m_value;
public:
MyClass():m_value(0){}
MyClass(int value):m_value(value){}
MyClass(int num1, int num2) :m_value(num1 + num2) {}
public:
int getValue() const{ return m_value; }
};
template<typename T>
T Add(const T& a, const T& b)
{
return a + b;
}
template<>
MyClass Add(const MyClass& a, const MyClass& b)
{
return MyClass(a.getValue(), b.getValue());
}
template<typename T>
void print(const T& value1, const T& value2, const T& result)
{
cout << value1 << "+" << value2 << "=" << result << endl;
}
template<>
void print(const MyClass& value1, const MyClass& value2, const MyClass& result)
{
cout << value1.getValue() << "+" << value2.getValue() << "=" << result.getValue() << endl;
}
int main()
{
const MyClass num1(2);
const MyClass num2(5);
const MyClass res(Add(num1, num2));
print(num1, num2, res);
return 0;
}
在本例中首选添加++和<<运算符支持。
#include<iostream>
using namespace std;
class MyClass
{
friend ostream& operator<<(ostream& os, const MyClass& myClass);
private:
int m_value;
public:
MyClass():m_value(0){}
MyClass(int value):m_value(value){}
MyClass(int num1, int num2) :m_value(num1 + num2) {}
MyClass operator+(const MyClass& other) const
{
return m_value + other.m_value;
}
};
ostream& operator<<(ostream& os, const MyClass& myClass)
{
os << myClass.m_value;
return os;
}
template<typename T>
T Add(const T& a, const T& b)
{
return a + b;
}
template<typename T>
void print(const T& value1, const T& value2, const T& result)
{
cout << value1 << "+" << value2 << "=" << result << endl;
}
int main()
{
const MyClass num1(2);
const MyClass num2(5);
const MyClass res(Add(num1, num2));
print(num1, num2, res);
return 0;
}
10.创建单例
将构造函数设为私有,防止外部直接创建对象,并且删除拷贝构造函数和赋值运算符。提供一个公共的静态成员函数来获取唯一实例。使用静态局部变量确保只初始化一次。
#include<iostream>
using namespace std;
class MySingleton
{
private:
int number;
private:
MySingleton(): number(100){}
MySingleton(const MySingleton&) = delete;
MySingleton& operator=(const MySingleton&) = delete;
public:
static MySingleton& getInstance() {
static MySingleton instance;
return instance;
}
void print() { cout << "singleton successfully printing!" << endl; }
int getNumber() { return number; }
};
int main()
{
MySingleton& instance = MySingleton::getInstance();
instance.print();
cout << instance.getNumber() << endl;
return 0;
}
使用模板来创建一个Singleton基类。
#include<iostream>
using namespace std;
template <typename T>
class Singleton
{
protected:
Singleton() {};
virtual ~Singleton() {};
Singleton(const Singleton&) = delete;
Singleton& operator=(const Singleton&) = delete;
public:
static T& getInstance() {
static T instance;
return instance;
}
};
class MySingleton : public Singleton<MySingleton>
{
private:
int number;
private:
MySingleton() : number(100) {}
friend class Singleton<MySingleton>;
public:
void print() { cout << "singleton successfully printing!" << endl; }
int getNumber() { return number; }
};
int main()
{
MySingleton& instance = MySingleton::getInstance();
instance.print();
cout << instance.getNumber() << endl;
return 0;
}
11.在编译时计算值
模板元编程利用C++模板编译器的优势在编译时计算数值,可以节省运行时的性能。
#include<iostream>
using namespace std;
//阶乘的普通函数
int factorial(int n) {
if (n == 0)
return 1;
return n * factorial(n - 1);
}
//阶乘的模板元程序
template <int N>
struct Factorial
{
static const int value = N * Factorial<N - 1>::value;
};
template <>
struct Factorial<0>
{
static const int value = 1;
};
int main()
{
//编译器计算
cout << Factorial<5>::value << endl;
//运行时计算
cout << factorial(5) << endl;
return 0;
}
12.C++20concept
概念可以用于对模板参数进行约束和限制。在编译时对泛型代码进行更严格的类型检查,提高代码的可读性和可维护性(#include<concepts>)。
#include<iostream>
#include<concepts>
using namespace std;
//约束为整数类型
template<typename T>
concept Integral = is_integral_v<T>;
template<Integral T>
void print(T value)
{
cout << value << endl;
}
int main()
{
short num = 2;
print(num);
return 0;
}