BLOG

#include <iostream>

struct alignas(16) Bar
{
    int i;                  // 4 bytes
    int n;                  // 4 bytes
    alignas(4) char arr[3];
    short s;                // 2 bytes
};

int main()
{
    std::cout << alignof(Bar) << std::endl; // output: 16
}

int main() {
    int intValue = 5;
    auto autoValue = intValue;         // 类型推导为 int

    const double doubleValue = 3.14;
    auto autoConstValue = doubleValue; // 类型推导为 const double

    std::vector<int> intVector = {1, 2, 3};
    for (auto it = intVector.begin(); it != intVector.end(); ++it) {
        // 使用 auto 在范围循环中简化代码
        std::cout << *it << " ";
    }

    return 0;
}

int main() {
    int x = 5;
    const int y = 10;
    int& ref = x;
    const int* ptr = &y;

    auto a = x;   // 推导为 int
    auto b = y;   // 推导为 const int
    auto c = ref; // 推导为 int（引用的目标类型）
    auto d = ptr; // 推导为 const int*（指针的类型）

    return 0;
}

int main() {
    int x = 5;
    const double y = 3.14;

    decltype(x) a = 10;    // 推导为 int
    decltype(y) b = 2.0; // 推导为 const double
    decltype(x + y) c = x + y; // 推导为 double

    return 0;
}

int var;
const int&& fx();
struct A { double x; }
const A* a = new A();

#include <iostream>
#include <typeinfo>

class Base {
public:
    virtual ~Base() {}
};

class Derived : public Base {
};

int main() {
    int intValue = 5;
    double doubleValue = 3.14;
    Base* basePtr = new Derived;

    const std::type_info& intTypeInfo = typeid(intValue);
    const std::type_info& doubleTypeInfo = typeid(doubleValue);
    const std::type_info& basePtrTypeInfo = typeid(basePtr);

    std::cout << "int type: "     << intTypeInfo.name()     << std::endl;
    std::cout << "double type: "  << doubleTypeInfo.name()  << std::endl;
    std::cout << "basePtr type: " << basePtrTypeInfo.name() << std::endl;

    delete basePtr;

    return 0;
}

#include <iostream>
#include <stdexcept>

void divide(int a, int b) {
    if (b == 0) {
        throw std::runtime_error("Division by zero"); // 引发异常
    }
    std::cout << "Result: " << a / b << std::endl;
}

int main() {
    try {
        divide(10, 0); // 传入0，会引发除零异常
    }
    catch (const std::runtime_error& e) { // 捕获std::runtime_error类型的异常
        std::cerr << "Caught an exception: " << e.what() << std::endl;
    }
    catch (...) { // 捕获所有其他类型的异常
        std::cerr << "Caught an unknown exception" << std::endl;
    }

    std::cout << "Program continues after exception handling." << std::endl;
    return 0;
}

int main() {
    const int x = 5;
    const int* ptr = &x;

    int* mutablePtr = const_cast<int*>(ptr); // 去除常量属性
    *mutablePtr = 10;                        // 可能导致未定义行为，修改了本应该是常量的对象

    return 0;
}

constexpr int factorial(int n) {
    return n <= 1 ? 1 : n * factorial(n - 1);
}

int main() {
    constexpr int x = 5;
    constexpr int y = factorial(x); // 编译时计算阶乘的结果
    static_assert(y == 120, "Factorial calculation is incorrect"); // 静态断言

    return 0;
}

class Base {
public:
    virtual void print() {
        std::cout << "Base" << std::endl;
    }
};

class Derived : public Base {
public:
    void print() override {
        std::cout << "Derived" << std::endl;
    }
};

int main() {
    Base* basePtr = new Derived;

    Derived* derivedPtr = dynamic_cast<Derived*>(basePtr);
    if (derivedPtr) {
        derivedPtr->print(); // 转换成功
    } else {
        std::cout << "Dynamic cast failed" << std::endl;
    }

    delete basePtr;
    return 0;
}

int main() {
    int intValue = 5;
    double doubleValue = static_cast<double>(intValue); // 整数到浮点数的转换

    double anotherDoubleValue = 3.14;
    int truncatedIntValue = static_cast<int>(anotherDoubleValue); // 浮点数到整数的转换，可能截断小数部分

    return 0;
}

int main() {
    int intValue = 42;
    double* doublePointer = reinterpret_cast<double*>(&intValue); // 将整数指针转换为双精度浮点数指针

    uintptr_t intValueAsInt = reinterpret_cast<uintptr_t>(&intValue); // 将指针转换为整数类型

    // 不安全的使用，可能会引发未定义行为
    int* unsafePointer = reinterpret_cast<int*>(intValueAsInt);

    return 0;
}

class MyClass {
public:
    explicit MyClass(int value) : data(value) {}
private:
    int data;
};

int main() {
    // 使用显式构造调用
    MyClass obj1(5);
    
    // 错误，不能隐式转换
    // MyClass obj2 = 10;
    
    // 正确，使用显式构造
    MyClass obj3 = MyClass(10);
    
    return 0;
}

class MyCounter {
public:
    MyCounter(int initialValue) : value(initialValue) {}

    int getValue() const {
        // 在 const 成员函数内修改 mutable 变量
        mutableValue++;
        return value;
    }

private:
    int value;
    mutable int mutableValue = 0; // 标记为 mutable 的成员变量
};

int main() {
    const MyCounter counter(5);
    int result = counter.getValue(); // 不会引发编译错误，mutable 变量可以被修改

    return 0;
}

void foo() noexcept {
    // 不会引发异常
}

void bar() noexcept(false) {
    throw std::runtime_error("An error occurred"); // 可能引发异常
}

int main() {
    try {
        bar(); // 在此处调用 bar，std::terminate 会被调用
    } catch (const std::exception& e) {
        std::cerr << "Exception caught: " << e.what() << std::endl;
    }

    return 0;
}

void anotherFunction() noexcept(noexcept(Allocator()));  // 如果 Allocator() 不会抛出异常，则 anotherFunction() 也不会抛出

template <typename T> void func() noexcept(noexcept(T()));  // 根据 T 的构造函数决定是否抛出

template <typename T, size_t Size>
class MyArray {
    static_assert(Size > 0, "Size must be greater than 0");
public:
    // ...
private:
    T data[Size];
};

int main() {
    MyArray<int, 0> array; // 编译失败，Size 必须大于 0
    return 0;
}

#include <iostream>
#include <thread>

thread_local int threadLocalVar = 0;

void threadFunction() {
    threadLocalVar++; // 每个线程修改自己的副本
    std::cout << "Thread-local variable: " << threadLocalVar << std::endl;
}

int main() {
    std::thread t1(threadFunction);
    std::thread t2(threadFunction);

    t1.join();
    t2.join();

    return 0;
}

template <class T>
class C1 : typename T::InnerType // Error - typename not allowed.
{};
template <class T>
class C2 : A<typename T::InnerType>  // typename OK.
{};

template<class T1, class T2>...
template<typename T1, typename T2>...

// typename.cpp
template<class T> class X
{
   typename T::Y m_y;   // treat Y as a type
};

int main()
{
}

int volatile nVint;

// when_to_use_inline_functions.cpp
class Point
{
public:
    // Define "accessor" functions as
    //  reference types.
    unsigned& x();
    unsigned& y();
private:
    unsigned _x;
    unsigned _y;
};

inline unsigned& Point::x()
{
    return _x;
}

inline unsigned& Point::y()
{
    return _y;
}

int main()
{
}

// inline_functions_macro.c
#include <stdio.h>
#include <conio.h>

#define toupper(a) ((a) >= 'a' && ((a) <= 'z') ? ((a)-('a'-'A')):(a))

int main() {
   char ch;
   printf_s("Enter a character: ");
   ch = toupper( getc(stdin) );
   printf_s( "%c", ch );
}

// inline_functions_inline.cpp
#include <stdio.h>
#include <conio.h>

inline char toupper( char a ) {
   return ((a >= 'a' && a <= 'z') ? a-('a'-'A') : a );
}

int main() {
   printf_s("Enter a character: ");
   char ch = toupper( getc(stdin) );
   printf_s( "%c", ch );
}

//定义一个新的命名空间，或为已有的命名空间增加新的元素
namespace namespace_name {
   // 代码声明
}

//调用name命名空间中的code
name::code;  // code 可以是变量或函数

class A {
  void f1(){};
};

class B : public virtual  A {
 void f2(){};
};

#include <iostream>
class Base {
public:
    void foo() {
        std::cout << "Base::foo()" << std::endl;
    }
};

class Derived : public Base {
public:
    using Base::foo; // 在派生类中引入基类的成员函数 foo
};

int main() {
    Derived d;
    d.foo(); // 调用引入的基类成员函数

    return 0;
}

const int x = 5;

void myFunction(const int x) {
  // x的值不能在函数中修改
}

const int myFunction() {
  return 5;
}

class MyClass {
public:
  int getValue() const {
    // 不能修改对象的状态
    return value;
  }
private:
  int value;
};

int x = 5;
const int* ptr = &x;
// *ptr不能用于修改x的值

#include <type_traits>

template <typename T>
void process(T value)
{
    // 静态断言：确保 T 是可复制构造类型
    static_assert(std::is_copy_constructible<T>::value, "T must be copy constructible");

    // 继续处理 value ...
}

int main()
{
    int x = 5;
    process(x); // 正常运行

    struct NonCopyable {
        NonCopyable(const NonCopyable&) = delete;
    };

    NonCopyable nc;
    process(nc); // 编译错误：T must be copy constructible

    return 0;
}

template <int N>
void myFunction(const int (&arr)[N]) {
  // 接受一个大小为N的数组
}

#include <iostream>

using namespace std;

void myFunction() {
  static int count = 0; // 静态变量
  count++;
  cout << "调用函数次数为：" << count << endl;
}

int main() {
  myFunction();
  myFunction();
  myFunction();
  return 0;
}

// 输出：
// 调用函数次数为：1
// 调用函数次数为：2
// 调用函数次数为：3

#include <iostream>

using namespace std;

class MyClass {
  public:
    static int count; // 静态成员变量
};

int MyClass::count = 0; // 静态成员变量的初始化

int main() {
  MyClass obj1;
  MyClass obj2;
  obj1.count = 5;
  cout << "obj1.count = " << obj1.count << endl; // 输出 5
  cout << "obj2.count = " << obj2.count << endl; // 输出 5
  obj2.count = 10;
  cout << "obj1.count = " << obj1.count << endl; // 输出 10
  cout << "obj2.count = " << obj2.count << endl; // 输出 10
  return 0;
}

namespace MyNamespace {
  static int x = 0;
}

#include <iostream>

using namespace std;

class MyClass {
  private:
    int x;
  public:
    static int count; // 静态成员变量
    static void myStaticFunction() { // 静态成员函数
      cout << "静态成员变量 count = " << count << endl;
      // cout << "非静态成员变量 x = " << x << endl; // 错误！不能访问非静态成员
    }
};

int MyClass::count = 0; // 静态成员变量的初始化

int main() {
  MyClass::myStaticFunction();
  return 0;
}

// 输出：
// 静态成员变量 count = 0

//使用NEW运算符在堆中开辟一块新空间，例程如下
#include <iostream>

using std::cout;

class A {
  public:
		A(){cout<<"构造函数执行完毕\n";};
};

int main() {
		A *p;     //声明一个属于A类的指针p
		p=new A;  //使用new运算符创建一块堆中空间，它的大小由类A的数据成员的类型和数量
							//来定，由于堆在内存中都是匿名的，因此这里没有为它命名，只是将它的内存
							//地址赋给了指针p
		// compile time array
		int ctarray[ 3 ]; //allocated on stack
		// run time array
		int* rtarray = new int[ 3 ]; //allocated on heap

		return 0;
}

int *p = new int;   // 动态分配一个int类型的对象
*p = 10;            // 给对象赋值
cout << *p << endl; // 输出对象的值
delete p;           // 释放内存空间

int n = 5;
int *p = new int[n];          // 动态分配一个包含5个int类型的数组
for (int i = 0; i < n; i++) {
  p[i] = i + 1;               // 给数组元素赋值
  cout << p[i] << " ";        // 输出数组元素
}
cout << endl;
delete[] p;                   // 释放内存空间

#include <iostream>

using namespace std;

class MyClass {
  public:
    MyClass() { // 构造函数
      cout << "MyClass constructed" << endl;
    }
    ~MyClass() { // 析构函数
      cout << "MyClass destroyed" << endl;
    }
};

int main() {
  void *p = operator new(sizeof(MyClass)); // 分配内存空间
  MyClass *q = new (p) MyClass();          // 在指定的内存地址上构造对象
  q->~MyClass();                           // 显式调用析构函数
  operator delete(p);                      // 释放内存空间
  return 0;
}

// 输出：
// MyClass constructed
// MyClass destroyed

#include <iostream>

using namespace std;

class A {
    int num;
public:
    A() {
        cout<<"A's constructor"<<endl;
    }
    ~A() {
        cout<<"~A"<<endl;
    }
    void show(){
        cout<<"num:"<<num<<endl;
    }
};

int main() {
    char mem[100];
    mem[0]='A';
    mem[1]='\0';
    mem[2]='\0';
    mem[3]='\0';
    cout<<(void*)mem<<endl;
    A* p = new (mem) A; // placement new
    cout<<p<<endl;
    p->show();
    p->~A();
    getchar();
}

// 程序运行结果： 
 0024F924 
 A’s constructor 
 0024F924 
 num:65 
 ~A

#include <iostream>

using namespace std;

class MyClass {
  public:
    void *operator new(size_t size) { // 重载new关键字
      cout << "MyClass::new" << endl;
      void *p = malloc(size);         // 分配内存空间
      return p;
    }
    void operator delete(void *p) {   // 重载delete关键字
      cout << "MyClass::delete" << endl;
      free(p);                        // 释放内存空间
    }
};

int main() {
  MyClass *p = new MyClass();         // 动态分配内存空间 
  delete p;                           // 释放内存空间 
  return 0; 
}

// 输出： 
// MyClass::new 
// MyClass::delete

namespace N
{
    template<class T>
    class Y // template definition
    {
        void mf() {}
    };
}

// template class Y<int>; // error: class template Y not visible in the global namespace
using N::Y;
// template class Y<int>; // error: explicit instantiation outside
                          // of the namespace of the template
template class N::Y<char*>;       // OK: explicit instantiation
template void N::Y<double>::mf(); // OK: explicit instantiation

template<class T>
struct Z // template definition
{
    void f() {}
    void g(); // never defined
};

template struct Z<double>; // explicit instantiation of Z<double>
Z<int> a;                  // implicit instantiation of Z<int>
Z<char>* p;                // nothing is instantiated here

p->f(); // implicit instantiation of Z<char> and Z<char>::f() occurs here.
        // Z<char>::g() is never needed and never instantiated:
        // it does not have to be defined

template<class T>
class X;    // declaration, not definition

X<char> ch; // error: incomplete type X<char>

#include <iostream>

// 类模板
template <typename T>
class MyClass {
public:
    void display() {
        std::cout << "Generic template" << std::endl;
    }
};

// 特化版本
template <>
class MyClass<int> {
public:
    void display() {
        std::cout << "Specialized template for int" << std::endl;
    }
};

int main() {
    MyClass<double> obj1;
    MyClass<int> obj2;

    obj1.display(); // 使用通用模板
    obj2.display(); // 使用特化模板

    return 0;
}

#include <iostream>

// 通用类模板
template <typename T, typename U>
class Pair {
public:
    void display() {
        std::cout << "Generic template" << std::endl;
    }
};

// 部分特化：当两个参数类型相同时
template <typename T>
class Pair<T, T> {
public:
    void display() {
        std::cout << "Partial specialization for same types" << std::endl;
    }
};

int main() {
    Pair<int, double> obj1;
    Pair<int, int> obj2;

    obj1.display(); // 通用模板
    obj2.display(); // 部分特化

    return 0;
}

#include <iostream>

// 类模板带默认参数
template <typename T = int, typename U = double>
class Pair {
public:
    T first;
    U second;

    Pair(T f, U s) : first(f), second(s) {}

    void display() {
        std::cout << "First: " << first << ", Second: " << second << std::endl;
    }
};

#include <algorithm>
#include <iostream>
#include <string>
#include <vector>

struct Printer
{
    // generic functor
std::ostream& os;
    Printer(std::ostream& os) : os(os) {}
    template<typename T>
    void operator()(const T& obj) { os << obj << ' '; } // member template
};

int main()
{
std::vector<int> v{1,2,3};
std::for_each(v.begin(), v.end(), Printer(std::cout));
std::string s{"abc"};
    std::ranges::for_each(s, Printer(std::cout));
}

struct A
{
    template<class T> struct B;        // primary member template
    template<class T> struct B<T*> {}; // OK: partial specialization
//  template<> struct B<int*> {};      // OK via CWG 727: full specialization
};
template<> struct A::B<int*> {};       // OK
template<class T> struct A::B<T&> {};  // OK

template<typename T1>
struct string
{
    // member template function
    template<typename T2>
    int compare(const T2&);
    // constructors can be templates too
    template<typename T2>
    string(conststd::basic_string<T2>& s) {/*...*/ }
};
// out of class definition of string<T1>::compare<T2>
template<typename T1> // for the enclosing class template
template<typename T2> // for the member template
int string<T1>::compare(const T2& s) {/* ... */ }

class Base
{
    virtual void f(int);
};

struct Derived : Base
{
    // this member template does not override Base::f
    template<class T> void f(T);

    // non-template member override can call the template:
    void f(int i) override
    {
         f<>(i);
    }
};

template<typename T>
struct A
{
    void f(int); // non-template member

    template<typename T2>
    void f(T2); // member template
};

// template member definition
template<typename T>
template<typename T2>
void A<T>::f(T2)
{
    // some code
}

int main()
{
    A<char> ac;
    ac.f('c'); // calls template function A<char>::f<char>(char)
    ac.f(1);   // calls non-template function A<char>::f(int)
    ac.f<>(1); // calls template function A<char>::f<int>(int)
}

struct X
{
    template<class T> T good(T n);
    template<class T> T bad(T n);
};

template<class T> struct identity { using type = T; };

// OK: equivalent declaration
template<class V>
V X::good(V n) { return n; }

// Error: not equivalent to any of the declarations inside X
template<class T>
T X::bad(typename identity<T>::type n) { return n; }

struct A
{
    template<typename T>
    operator T*(); // conversion to pointer to any type
};

// out-of-class definition
template<typename T>
A::operator T*() { return nullptr; }

// explicit specialization for char*
template<>
A::operator char*() { return nullptr; }

// explicit instantiation
template A::operator void*();

int main()
{
    A a;
    int* ip = a.operator int*(); // explicit call to A::operator int*()
}

struct S //c++ 14起
{
    operator auto() const { return 10; } // OK
    template<class T> operator auto() const { return 42; } // error
};

template<class T>
constexpr T pi = T(3.1415926535897932385L); // variable template

template<class T>
T circular_area(T r) // function template
{
    return pi<T> * r * r; // pi<T> is a variable template instantiation
}

using namespace std::literals;
struct matrix_constants
{
    template<class T>
    using pauli = hermitian_matrix<T, 2>; // alias template

    template<class T> // static data member template
    static constexpr pauli<T> sigmaX = {{0, 1}, {1, 0}};

    template<class T>
    static constexpr pauli<T> sigmaY = {{0, -1i}, {1i, 0}};

    template<class T>
    static constexpr pauli<T> sigmaZ = {{1, 0}, {0, -1}};
};

struct limits
{
    template<typename T>
    static const T min; // declaration of a static data member template
};

template<typename T>
const T limits::min = { }; // definition of a static data member template

template<class T>
class X
{
    static T s; // declaration of a non-template static data member of a class template
};

template<class T>
T X<T>::s = 0; // definition of a non-template data member of a class template

void f1(auto); // same as template<class T> void f1(T)
void f2(C1 auto); // same as template<C1 T> void f2(T), if C1 is a concept
void f3(C2 auto...); // same as template<C2... Ts> void f3(Ts...), if C2 is a concept
void f4(const C3 auto*, C4 auto&); // same as template<C3 T, C4 U> void f4(const T*, U&);

template<class T, C U>
void g(T x, U y, C auto z); // same as template<class T, C U, C W> void g(T x, U y, W z);

template<>
void f4<int>(const int*, const double&); // specialization of f4<int, const double>

template<typename T>
void f(T s)
{
std::cout << s << '\n';
}

template void f<double>(double); // instantiates f<double>(double)
template void f<>(char);         // instantiates f<char>(char),template argument deduced
template void f(int);            // instantiates f<int>(int), template argument deduced

char* p = 0;
 
template<class T>
T g(T x = &p) { return x; }
 
template int g<int>(int); // OK even though &p isn’t an int.

#include <iostream>
 
template<typename T>
void f(T s)
{
    std::cout << s << '\n';
}
 
int main()
{
    f<double>(1); // instantiates and calls f<double>(double)
    f<>('a');     // instantiates and calls f<char>(char)
    f(7);         // instantiates and calls f<int>(int)
    void (*pf)(std::string) = f; // instantiates f<string>(string)
    pf("∇");                     // calls f<string>(string)
}

template<typename T>
constexpr int f() { return T::value; }
 
template<bool B, typename T>
void g(decltype(B ? f<T>() : 0));
template<bool B, typename T>
void g(...);
 
template<bool B, typename T>
void h(decltype(int{B ? f<T>() : 0}));
template<bool B, typename T>
void h(...);
 
void x()
{
    g<false, int>(0); // OK: B ? f<T>() : 0 is not potentially constant evaluated
    h<false, int>(0); // error: instantiates f<int> even though B evaluates to false
                      // and list-initialization of int from int cannot be narrowing
}

template<typename To, typename From>
To convert(From f);
 
void g(double d) 
{
    int i = convert<int>(d);    // calls convert<int,double>(double)
    char c = convert<char>(d);  // calls convert<char,double>(double)
    int(*ptr)(float) = convert; // instantiates convert<int, float>(float)
}

#include <iostream>
 
int main() 
{
    std::cout << "Hello, world" << std::endl;
    // operator<< is looked up via ADL as std::operator<<,
    // then deduced to operator<<<char, std::char_traits<char>> both times
    // std::endl is deduced to &std::endl<char, std::char_traits<char>>
}

template<class... Types>
void f(Types... values);
 
void g()
{
    f<int*, float*>(0, 0, 0); // Types = {int*, float*, int}
}

template<class T>
void f(T t);
 
template<class X>
void g(const X x);
 
template<class Z>
void h(Z z, Z* zp);
 
// two different functions with the same type, but 
// within the function, t has different cv qualifications
f<int>(1);       // function type is void(int), t is int
f<const int>(1); // function type is void(int), t is const int
 
// two different functions with the same type and the same x
// (pointers to these two functions are not equal,
//  and function-local statics would have different addresses)
g<int>(1);       // function type is void(int), x is const int
g<const int>(1); // function type is void(int), x is const int
 
// only top-level cv-qualifiers are dropped:
h<const int>(1, NULL); // function type is void(int, const int*) 
                       // z is const int, zp is const int*

template<int I, int J>
A<I+J> f(A<I>, A<J>); // overload #1
 
template<int K, int L>
A<K+L> f(A<K>, A<L>); // same as #1
 
template<int I, int J>
A<I-J> f(A<I>, A<J>); // overload #2

template<int I, int J>
void f(A<I+J>); // template overload #1
 
template<int K, int L>
void f(A<K+L>); // equivalent to #1

template<class T>
decltype(g(T())) h(); // decltype(g(T())) is a dependent type
 
int g(int);
 
template<class T>
decltype(g(T())) h()
{                  // redeclaration of h() uses earlier lookup
    return g(T()); // although the lookup here does find g(int)
}
 
int i = h<int>(); // template argument substitution fails; g(int)
                  // was not in scope at the first declaration of h()

// equivalent
template<int I>
void f(A<I>, A<I+10>); // overload #1
template<int I>
void f(A<I>, A<I+10>); // redeclaration of overload #1
 
// not equivalent
template<int I>
void f(A<I>, A<I+10>); // overload #1
template<int I>
void f(A<I>, A<I+11>); // overload #2
 
// functionally-equivalent but not equivalent
// This program is ill-formed, no diagnostic required
template<int I>
void f(A<I>, A<I+10>);      // overload #1
template<int I>
void f(A<I>, A<I+1+2+3+4>); // functionally equivalent

template<class X>
void f(X a);
template<class X>
void f(X* a);
 
int* p;
f(p);

template<class X>
void f(X a);
template<class X>
void f(X* a);
 
void (*p)(int*) = &f;

template<class X>
void f(X a);  // first template f
template<class X>
void f(X* a); // second template f
template<>
void f<>(int *a) {} // explicit specialization
 
// template argument deduction comes up with two candidates:
// f<int*>(int*) and f<int>(int*)
// partial ordering selects f<int>(int*) as more specialized

struct A {};
 
template<class T>
struct B
{
    template<class R>
    int operator*(R&); // #1
};
 
template<class T, class R>
int operator*(T&, R&); // #2
 
int main()
{
    A a;
    B<A> b;
    b * a; // template argument deduction for int B<A>::operator*(R&) gives R=A 
           //                             for int operator*(T&, R&), T=B<A>, R=A
 
    // For the purpose of partial ordering, the member template B<A>::operator*
    // is transformed into template<class R> int operator*(B<A>&, R&);
 
    // partial ordering between 
    //     int operator*(   T&, R&)  T=B<A>, R=A
    // and int operator*(B<A>&, R&)  R=A 
    // selects int operator*(B<A>&, A&) as more specialized
}

template<class T>
void f(T);        // template #1
template<class T>
void f(T*);       // template #2
template<class T>
void f(const T*); // template #3

void m()
{
    const int* p;
    f(p); // overload resolution picks: #1: void f(T ) [T = const int *]
          //                            #2: void f(T*) [T = const int]
          //                            #3: void f(const T *) [T = int]

    // partial ordering:

    // #1 from transformed #2: void(T) from void(U1*): P=T A=U1*: deduction ok: T=U1*
    // #2 from transformed #1: void(T*) from void(U1): P=T* A=U1: deduction fails
    // #2 is more specialized than #1 with regards to T

    // #1 from transformed #3: void(T) from void(const U1*): P=T, A=const U1*: ok
    // #3 from transformed #1: void(const T*) from void(U1): P=const T*, A=U1: fails
    // #3 is more specialized than #1 with regards to T

    // #2 from transformed #3: void(T*) from void(const U1*): P=T* A=const U1*: ok
    // #3 from transformed #2: void(const T*) from void(U1*): P=const T* A=U1*: fails
    // #3 is more specialized than #2 with regards to T

    // result: #3 is selected
    // in other words, f(const T*) is more specialized than f(T) or f(T*)
}

template<class T>
void f(T, T*);   // #1
template<class T>
void f(T, int*); // #2

void m(int* p)
{
    f(0, p); // deduction for #1: void f(T, T*) [T = int]
             // deduction for #2: void f(T, int*) [T = int]

    // partial ordering:

    // #1 from #2: void(T,T*) from void(U1,int*): P1=T, A1=U1: T=U1
    //                                            P2=T*, A2=int*: T=int: fails

    // #2 from #1: void(T,int*) from void(U1,U2*): P1=T A1=U1: T=U1
    //                                             P2=int* A2=U2*: fails

    // neither is more specialized w.r.t T, the call is ambiguous
}

template<class T>
void g(T);  // template #1
template<class T>
void g(T&); // template #2

void m()
{
    float x;
    g(x); // deduction from #1: void g(T ) [T = float]
          // deduction from #2: void g(T&) [T = float]

    // partial ordering:

    // #1 from #2: void(T) from void(U1&): P=T, A=U1 (after adjustment), ok

    // #2 from #1: void(T&) from void(U1): P=T (after adjustment), A=U1: ok

    // neither is more specialized w.r.t T, the call is ambiguous
}

template<class T>
struct A { A(); };

template<class T>
void h(const T&); // #1
template<class T>
void h(A<T>&);    // #2

void m()
{
    A<int> z;
    h(z); // deduction from #1: void h(const T &) [T = A<int>]
          // deduction from #2: void h(A<T> &) [T = int]

    // partial ordering:

    // #1 from #2: void(const T&) from void(A<U1>&): P=T A=A<U1>: ok T=A<U1>

    // #2 from #1: void(A<T>&) from void(const U1&): P=A<T> A=const U1: fails

    // #2 is more specialized than #1 w.r.t T

    const A<int> z2;
    h(z2); // deduction from #1: void h(const T&) [T = A<int>]
           // deduction from #2: void h(A<T>&) [T = int], but substitution fails

    // only one overload to choose from, partial ordering not tried, #1 is called
}

template<class T>
void f(T);         // #1
template<class T>
void f(T*, int = 1); // #2

void m(int* ip)
{
    int* ip;
    f(ip); // calls #2 (T* is more specialized than T)
}

template<class T>
void g(T);       // #1
template<class T>
void g(T*, ...); // #2

void m(int* ip)
{
    g(ip); // calls #2 (T* is more specialized than T)
}

template<class T, class U>
struct A {};

template<class T, class U>
void f(U, A<U, T>* p = 0); // #1
template<class U>
void f(U, A<U, U>* p = 0); // #2

void h()
{
    f<int>(42, (A<int, int>*)0); // calls #2
    f<int>(42);                  // error: ambiguous
}

template<class T>
void g(T, T = T()); // #1
template<class T, class... U>
void g(T, U...);    // #2

void h()
{
    g(42); // error: ambiguous
}

template<class T, class... U>
void f(T, U...); // #1
template<class T>
void f(T);       // #2

void h(int i)
{
    f(&i); // calls #2 due to the tie-breaker between parameter pack and no parameter
           // (note: was ambiguous between DR692 and DR1395)
}

template<class T, class... U>
void g(T*, U...); // #1
template<class T>
void g(T);        // #2

void h(int i)
{
    g(&i); // OK: calls #1 (T* is more specialized than T)
}

template<class... T>
int f(T*...);    // #1
template<class T>
int f(const T&); // #2

f((int*)0); // OK: selects #2; non-variadic template is more specialized than
            // variadic template (was ambiguous before DR1395 because deduction
            // failed in both directions)

template<class... Args>
void f(Args... args);        // #1
template<class T1, class... Args>
void f(T1 a1, Args... args); // #2
template<class T1, class T2>
void f(T1 a1, T2 a2);        // #3

f();        // calls #1
f(1, 2, 3); // calls #2
f(1, 2);    // calls #3; non-variadic template #3 is more
            // specialized than the variadic templates #1 and #2

template<class T>
T f(int); // #1
template<class T, class U>
T f(U);   // #2

void g()
{
    f<int>(1); // specialization of #1 is explicit: T f(int) [T = int]
               // specialization of #2 is deduced:  T f(U) [T = int, U = int]

    // partial ordering (only considering the argument type):

    // #1 from #2: T(int) from U1(U2): fails
    // #2 from #1: T(U) from U1(int): ok: U=int, T unused

    // calls #1
}

template<class...>
struct Tuple {};

template<class... Types>
void g(Tuple<Types...>);      // #1
template<class T1, class... Types>
void g(Tuple<T1, Types...>);  // #2
template<class T1, class... Types>
void g(Tuple<T1, Types&...>); // #3

g(Tuple<>());            // calls #1
g(Tuple<int, float>());  // calls #2
g(Tuple<int, float&>()); // calls #3
g(Tuple<int>());         // calls #3

template<class T>
void f(T);      // #1: template overload
template<class T>
void f(T*);     // #2: template overload
 
void f(double); // #3: non-template overload
template<>
void f(int);    // #4: specialization of #1
 
f('a');        // calls #1
f(new int(1)); // calls #2
f(1.0);        // calls #3
f(1);          // calls #4

template<class T>
void f(T);    // #1: overload for all types
template<>
void f(int*); // #2: specialization of #1 for pointers to int
template<class T>
void f(T*);   // #3: overload for all pointer types
 
f(new int(1)); // calls #3, even though specialization of #1 would be a perfect match

template<class T>
struct Alloc {};
 
template<class T>
using Vec = vector<T, Alloc<T>>; // type-id is vector<T, Alloc<T>>
 
Vec<int> v; // Vec<int> is the same as vector<int, Alloc<int>>

template<typename...>
using void_t = void;
 
template<typename T>
void_t<typename T::foo> f();
 
f<int>(); // error, int does not have a nested type foo

template<class T>
struct A;

template<class T>
using B = typename A<T>::U; // type-id is A<T>::U

template<class T>
struct A { typedef B<T> U; };

B<short> b; // error: B<short> uses its own type via A<short>::U

template<class T>
using A = decltype([] {}); // A<int> and A<char> refer to different closure types

vector<T> v; //empty vector
vector<T> v(n, value);//vector with n copies of value
vector<T> v(n);//vector with n copies of default for T

#include <iostream>
#include <vector>

class MyClass {
public:
    MyClass(int value) : data(value) {
        std::cout << "Constructor called for value: " << value << std::endl;
    }

private:
    int data;
};

int main() {
    std::vector<MyClass> vec;

    vec.push_back(MyClass(1)); // 调用构造函数，然后拷贝临时对象到容器中
    vec.emplace_back(2); // 在容器中直接构造对象，避免了拷贝操作

    return 0;
}