C++17完整导引-模板特性之占位符类型模板参数

最新推荐文章于 2024-10-22 14:57:52 发布
最新推荐文章于 2024-10-22 14:57:52 发布
阅读量930 收藏
点赞数
分类专栏： C++ 文章标签： c++ 开发语言
本文原创作者：-西门吹雪 MMTS_yang
本文链接：https://blog.csdn.net/mmts_yang/article/details/130773007
版权
自C++17开始，可以使用`auto`和`decltype(auto)`作为非类型模板参数，使得泛型编程能处理不同类型的参数。这包括使用`auto`声明变量模板，允许推导类型和值，以及用`decltype(auto)`模板参数处理表达式的值类型。此外，文章还展示了如何利用这些特性创建元编程常量、处理不同类型的参数列表，并讨论了使用占位符类型时可能遇到的限制和效果。
摘要由CSDN通过智能技术生成

占位符类型作为模板参数


自从 C++17起，你可以使用占位符类型（ auto和 decltype(auto)）作为 非类型模板参数的类型。这意味着我们可以写出泛型代码来处理不同类型的非类型模板参数。

使用auto模板参数

自从C++17起，你可以使用auto来声明非类型模板参数。例如：

#include <iostream>
using namespace std;

template<auto N> struct S {
    S(){cout <<" S Constructor " << N <<endl;}
};

这允许我们为不同类型实例化非类型模板参数N：

int main() {
   S<42> s1; // OK：S中N的类型是int
   S<'A'> s2;// OK：S中N的类型是char
}

运行结果如下：

 S Constructor 42
 S Constructor A

预处理代码如下：

#include <iostream>
using namespace std;

template<auto N>
struct S
{
  inline S()
  {
    operator<<(operator<<(std::operator<<(std::cout, " S Constructor "), N), endl);
  }
  
};

/* First instantiated from: insights.cpp:10 */
#ifdef INSIGHTS_USE_TEMPLATE
template<>
struct S<42>
{
  inline S()
  {
    std::operator<<(std::cout, " S Constructor ").operator<<(42).operator<<(std::endl);
  }
  
};

#endif
/* First instantiated from: insights.cpp:11 */
#ifdef INSIGHTS_USE_TEMPLATE
template<>
struct S<'A'>
{
  inline S()
  {
    std::operator<<(std::operator<<(std::cout, " S Constructor "), 'A').operator<<(std::endl);
  }
  
};
#endif
int main()
{
  S<42> s1 = S<42>();
  S<'A'> s2 = S<'A'>();
  return 0;
}

然而，你不能使用这个特性来实例化一些不允许作为模板参数的类型：

S<2.5> s3;  // ERROR：模板参数的类型不能是double

我们甚至还可以用指明类型的版本作为部分特化版：

template<int N> class S<N> {};

示例代码如下：

#include <iostream>
using namespace std;

template <auto N>
struct S {
    S() { cout << " S Constructor " << N << endl; }
};
template<long N> struct S<N> {
    S() { cout << " S Constructor special " << N << endl; }
};
int main() {
    S<42> s1;
    S<'A'> s2;
    S<42l> s3;
}

甚至还支持类模板参数推导。例如：

template<typename T, auto N>
class A {
public:
    A(const std::array<T, N>&) {
    }
    A(T(&)[N]) {
    }
    ...
};

这个类可以推导出T的类型、N的类型、N的值：

A a2{"hello"};  // OK，推导为A<const char, 6>，N的类型是std::size_t

std::array<double, 10> sa1;
A a1{sa1};      // OK，推导为A<double, 10>，N的类型是std::size_t

预处理代码如下：

#include <array>
#include <iostream>
using namespace std;

template<typename T, auto N>
class A
{
  public: 
  inline A(const std::array<T, N> &)
  {
  }
  inline A(T (&)[N])
  {
  }
  
};

/* First instantiated from: insights.cpp:13 */
#ifdef INSIGHTS_USE_TEMPLATE
template<>
class A<const char, 6>
{
  public: 
  inline A(const std::array<const char, 6> &);
  
  inline A(const char (&)[6])
  {
  } 
};
#endif
/* First instantiated from: insights.cpp:15 */
#ifdef INSIGHTS_USE_TEMPLATE
template<>
class A<double, 10>
{
  public: 
  inline A(const std::array<double, 10> &)
  {
  }
  inline A(double (&)[10]);
  
};
#endif

/* First instantiated from: insights.cpp:15 */
#ifdef INSIGHTS_USE_TEMPLATE
template<>
A(const std::array<double, 10> &) -> A<double, 10>;
#endif

/* First instantiated from: insights.cpp:13 */
#ifdef INSIGHTS_USE_TEMPLATE
template<>
A(const char (&)[6]) -> A<const char, 6>;
#endif

int main()
{
  A<const char, 6> a2 = A<const char, 6>{"hello"};
  std::array<double, 10> sa1 = std::array<double, 10>();
  A<double, 10> a1 = A<double, 10>{sa1};
  return 0;
}

你也可以修饰auto，例如，可以确保参数类型必须是个指针：
非类型模板参数可以是指针，但该指针必须指向外部链接对象,此项使用的详细解释

template<const auto* P> struct S; //

另外，通过使用可变参数模板，你可以使用多个不同类型的模板参数来实例化模板：

template<auto... VS> class HeteroValueList {
};

也可以用多个相同类型的参数：

template<auto V1, decltype(V1)... VS> class HomoValueList {
};

完整示例如下：

#include <array>
#include <iostream>
using namespace std;

template <const auto* P>
struct S {
    S() { cout << "S = " << (P) << endl; }
};
template <auto... VS>
class HeteroValueList {
   public:
    HeteroValueList() { cout << "HeteroValueList = " << (... + VS) << endl; }
};
template <auto V1, decltype(V1)... VS>
class HomoValueList {
   public:
    HomoValueList() {
        cout << "HomoValueList V1= " << V1 << " other = " << (... + VS) << endl;
    }
};
int main() {
    static char str1[] = "Test 1";
    S<str1> x;
    HeteroValueList<1, 2, 3> vals1;       // OK
    HeteroValueList<1, 'a', true> vals2;  // OK
    HomoValueList<1, 2, 3> vals3;         // OK
    HomoValueList<1, 'a', 3> vals4;       // OK
}

运行结果如下：

S = Test 1
HeteroValueList = 6
HeteroValueList = 99
HomoValueList V1= 1 other = 5
HomoValueList V1= 1 other = 100

预编译代码如下：

#include <array>
#include <iostream>
using namespace std;

template<const auto * P>
struct S
{
  inline S()
  {
    operator<<(operator<<(std::operator<<(std::cout, "S = "), (P)), endl);
  }
  
};

/* First instantiated from: insights.cpp:26 */
#ifdef INSIGHTS_USE_TEMPLATE
template<>
struct S<&str1>
{
  inline S()
  {
    std::operator<<(std::operator<<(std::cout, "S = "), (str1)).operator<<(std::endl);
  }
  
};
#endif


template<auto ...VS>
class HeteroValueList
{
  
  public: 
  inline HeteroValueList()
  {
    operator<<(operator<<(std::operator<<(std::cout, "HeteroValueList = "), (... + VS)), endl);
  }
};

/* First instantiated from: insights.cpp:27 */
#ifdef INSIGHTS_USE_TEMPLATE
template<>
class HeteroValueList<1, 2, 3>
{
  
  public: 
  inline HeteroValueList()
  {
    std::operator<<(std::cout, "HeteroValueList = ").operator<<((1 + 2) + 3).operator<<(std::endl);
  } 
};

#endif
/* First instantiated from: insights.cpp:28 */
#ifdef INSIGHTS_USE_TEMPLATE
template<>
class HeteroValueList<1, 'a', true>
{
  
  public: 
  inline HeteroValueList()
  {
    std::operator<<(std::cout, "HeteroValueList = ").operator<<((1 + static_cast<int>('a')) + static_cast<int>(true)).operator<<(std::endl);
  }
  
};
#endif


template<auto V1, decltype(V1) ...VS>
class HomoValueList
{
  
  public: 
  inline HomoValueList()
  {
    operator<<(operator<<(operator<<(operator<<(std::operator<<(std::cout, "HomoValueList V1= "), V1), " other = "), (... + VS)), endl);
  }
  
};

/* First instantiated from: insights.cpp:29 */
#ifdef INSIGHTS_USE_TEMPLATE
template<>
class HomoValueList<1, 2, 3>
{
  
  public: 
  inline HomoValueList()
  {
    std::operator<<(std::operator<<(std::cout, "HomoValueList V1= ").operator<<(1), " other = ").operator<<(2 + 3).operator<<(std::endl);
  }
  
};
#endif
/* First instantiated from: insights.cpp:30 */
#ifdef INSIGHTS_USE_TEMPLATE
template<>
class HomoValueList<1, 97, 3>
{
  
  public: 
  inline HomoValueList()
  {
    std::operator<<(std::operator<<(std::cout, "HomoValueList V1= ").operator<<(1), " other = ").operator<<(97 + 3).operator<<(std::endl);
  }
  
};
#endif

int main()
{
  static char str1[7] = "Test 1";
  S<&str1> x = S<&str1>();
  HeteroValueList<1, 2, 3> vals1 = HeteroValueList<1, 2, 3>();
  HeteroValueList<1, 'a', true> vals2 = HeteroValueList<1, 'a', true>();
  HomoValueList<1, 2, 3> vals3 = HomoValueList<1, 2, 3>();
  HomoValueList<1, 97, 3> vals4 = HomoValueList<1, 97, 3>();
  return 0;
}

字符和字符串模板参数

可以定义一个既可能是字符也可能是字符串的模板参数。例如，我们可以像下面这样改进用折叠表达式输出任意数量参数的方法：

#include <iostream>

template<auto Sep = ' ', typename First, typename... Args>
void print(const First& first, const Args&... args) {
    std::cout << first;
    auto outWithSep = [] (const auto& arg) {
                          std::cout << Sep << arg;
                      };
    (... , outWithSep(args));
    std::cout << '\n';
}

将默认的参数分隔符Sep设置为空格，我们可以实现和之前相同的效果：

template<auto Sep = ' ', typename First, typename... Args>
void print(const First& firstarg, const Args&... args) {
    ...
}

我们仍然可以像之前一样调用：

std::string s{"world"};
print(7.5, "hello", s);      // 打印出：7.5 hello world

然而，通过把分隔符Sep参数化，我们也可以显示指明另一个字符作为分隔符：

print<'-'>(7.5, "hello", s); // 打印出：7.5-hello-world

甚至，因为使用了auto，我们甚至可以传递被声明为无链接的字符串字面量作为分隔符：

static const char sep[] = ", ";
print<sep>(7.5, "hello", s); // 打印出：7.5, hello, world

另外，我们也可以传递任何其他可以用作模板参数的类型：

print<-11>(7.5, "hello", s); // 打印出：7.5-11hello-11world

定义元编程常量

定义编译期常量的更加容易。

原本的下列代码：

template<typename T, T v>
struct constant
{
    static constexpr T value = v;
};

using i = constant<int, 42>;
using c = constant<char, 'x'>;
using b = constant<bool, true>;

现在可以简单的实现为：

template<auto v>
struct constant
{
    static constexpr auto value = v;
};

using i = constant<42>;
using c = constant<'x'>;
using b = constant<true>;

完整示例：

#include <array>
#include <iostream>
using namespace std;
template <auto v>
struct constant {
    static constexpr auto value = v;
};
using i = constant<42>;
using c = constant<'x'>;
using b = constant<true>;
int main() {
    i jj;
  	c jj1;
  	b jj2;
}

预处理代码如下：

#include <array>
#include <iostream>
using namespace std;

template<auto v>
struct constant
{
  inline static constexpr const auto value = v;
};

/* First instantiated from: insights.cpp:14 */
#ifdef INSIGHTS_USE_TEMPLATE
template<>
struct constant<42>
{
  inline static constexpr const int value = 42;
  // inline constexpr constant() noexcept = default;
};

#endif
/* First instantiated from: insights.cpp:15 */
#ifdef INSIGHTS_USE_TEMPLATE
template<>
struct constant<'x'>
{
  inline static constexpr const char value = 'x';
  // inline constexpr constant() noexcept = default;
};

#endif
/* First instantiated from: insights.cpp:16 */
#ifdef INSIGHTS_USE_TEMPLATE
template<>
struct constant<true>
{
  inline static constexpr const bool value = true;
  // inline constexpr constant() noexcept = default;
};

#endif
using i = constant<42>;
using c = constant<'x'>;
using b = constant<true>;

int main()
{
  constant<42> jj = constant<42>();
  constant<'x'> jj1 = constant<'x'>();
  constant<true> jj2 = constant<true>();
  return 0;
}

同样，原本的下列代码：

template<typename T, T... Elements>
struct sequence {
};

using indexes = sequence<int, 0, 3, 4>;

现在可以简单的实现为：

template<auto... Elements>
struct sequence {
};

using indexes = sequence<0, 3, 4>;

预处理代码如下：

template<typename T, T ...Elements>
struct sequence
{
};

/* First instantiated from: insights.cpp:11 */
#ifdef INSIGHTS_USE_TEMPLATE
template<>
struct sequence<int, 0, 3, 4>
{
  // inline constexpr sequence() noexcept = default;
};

#endif

using indexes = sequence<int, 0, 3, 4>;

int main()
{
  sequence<int, 0, 3, 4> i = sequence<int, 0, 3, 4>();
  return 0;
}

你现在甚至可以定义一个持有若干不同类型的值的编译期对象（类似于一个简单的tuple）：

using tuple = sequence<0, 'h', true>;

使用auto作为变量模板的参数

你也可以使用auto作为模板参数来实现 变量模板(variable templates) 。
例如，下面的声明定义了一个变量模板arr，它的模板参数分别是元素的类型和数量：

template<typename T, auto N> std::array<T, N> arr;

在每个编译单元中，所有对arr<int, 10>的引用将指向同一个全局对象。而arr<long, 10>和arr<int, 10u>将指向其他对象（每一个都可以在所有编译单元中使用）。作为一个完整的例子，考虑如下的头文件：

#ifndef VARTMPLAUTO_HPP
#define VARTMPLAUTO_HPP

#include <array>
template<typename T, auto N> std::array<T, N> arr{};

void printArr();

#endif // VARTMPLAUTO_HPP

这里，我们可以在一个编译单元内修改两个变量模板的不同实例：

#include "vartmplauto.hpp"

int main()
{
    arr<int, 5>[0] = 17;
    arr<int, 5>[3] = 42;
    arr<int, 5u>[1] = 11;
    arr<int, 5u>[3] = 33;
    printArr();
}

另一个编译单元内可以打印这两个变量模板：

#include "vartmplauto.hpp"
#include <iostream>

void printArr()
{
    std::cout << "arr<int, 5>:  ";
    for (const auto& elem : arr<int, 5>) {
        std::cout << elem << ' ';
    }
    std::cout << "\narr<int, 5u>: ";
    for (const auto& elem : arr<int, 5u>) {
        std::cout << elem << ' ';
    }
    std::cout << '\n';
}

程序的输出将是：

arr<int, 5>:  17 0 0 42 0
arr<int, 5u>: 0 11 0 33 0

用同样的方式你可以声明一个任意类型的常量变量模板，类型可以通过初始值推导出来：

template<auto N> constexpr auto val = N; // 自从C++17起OK

之后可以像下面这样使用：

auto v1 = val<5>;       // v1 == 5，v1的类型为int
auto v2 = val<true>;    // v2 == true，v2的类型为bool
auto v3 = val<'a'>;     // v3 == 'a'，v3的类型为char

这里解释了发生了什么：

std::is_same_v<decltype(val<5>), int>       // 返回false
std::is_same_v<decltype(val<5>), const int> // 返回true
std::is_same_v<decltype(v1), int>           // 返回true（因为auto会退化）

使用decltype(auto)模板参数

你现在也可以使用另一个占位类型decltype(auto)（C++14引入）作为模板参数。注意，这个占位类型的推导有非常特殊的规则。根decltype的规则，如果使用decltype(auto)来推导 表达式(expressions) 而不是变量名，那么推导的结果将依赖于表达式的值类型：

  • prvalue（例如临时变量）推导出 type
  • lvalue（例如有名字的对象）推导出 type&
  • xvalue（例如用std::move()标记的对象）推导出 type&&
    这意味着你很容易就会把模板参数推导为引用，这可能导致一些令人惊奇的效果。
    例如：
#include <iostream>

template<decltype(auto) N>
struct S {
    void printN() const {
        std::cout << "N: " << N << '\n';
    }
};

static const int c = 42;
static int v = 42;

int main()
{
    S<c> s1;        // N的类型推导为const int 42
    S<(c)> s2;      // N的类型推导为const int&，N是c的引用
    s1.printN();
    s2.printN();

    S<(v)> s3;      // N的类型推导为int&，N是v的引用
    v = 77;
    s3.printN();    // 打印出：N: 77
}

运行结果如下；

N: 42
N: 42
N: 77

预处理代码如下：

#include <iostream>

template<decltype(auto) N>
struct S
{
  inline void printN() const
  {
    (std::operator<<(std::cout, "N: ") << N) << '\n';
  }
  
};

/* First instantiated from: insights.cpp:15 */
#ifdef INSIGHTS_USE_TEMPLATE
template<>
struct S<42>
{
  inline void printN() const
  {
    std::operator<<(std::operator<<(std::cout, "N: ").operator<<(42), '\n');
  }
  
  // inline constexpr S() noexcept = default;
};

#endif
/* First instantiated from: insights.cpp:16 */
#ifdef INSIGHTS_USE_TEMPLATE
template<>
struct S<&c>
{
  inline void printN() const
  {
    std::operator<<(std::operator<<(std::cout, "N: ").operator<<(c), '\n');
  }
  
  // inline constexpr S() noexcept = default;
};

#endif
/* First instantiated from: insights.cpp:20 */
#ifdef INSIGHTS_USE_TEMPLATE
template<>
struct S<&v>
{
  inline void printN() const
  {
    std::operator<<(std::operator<<(std::cout, "N: ").operator<<(v), '\n');
  }
  
  // inline constexpr S() noexcept = default;
};

#endif


static const int c = 42;

static int v = 42;

int main()
{
  S<42> s1 = S<42>();
  S<&c> s2 = S<&c>();
  s1.printN();
  s2.printN();
  S<&v> s3 = S<&v>();
  v = 77;
  s3.printN();
  return 0;
}
C++17 非类型模板参数的auto 和 DevC++ 支持C++17
bcbobo21cn的专栏
01-13 3522
模板参数分为两种，一种是类型模板参数，也是我们用得最多的一种： template <typename T, typename U> auto add(T t, U u) { return t+u; } 里面的 T 和 U 都是类型模板参数。 另一种是非类型模板参数，它可以让不同的字面量成为模板的参数： template <typename T, int BufSize> class buffer_t { public: T& alloc...
C++模板元编程（4） 非类型模板参数（Non-type template parameter）
二进制君
04-04 3082
参考：https://en.cppreference.com/w/cpp/language/template_parameters。
C++17 之 "利用构造函数推导模板参数类型"
ding_yingzi的博客
04-13 2307
演示用的模板类 C++17 之前的做法 C++17 的做法 某些情况 总结 在 C++17 之前, 通过向模板类的构造函数传递参数无法推导出类的模板参数类型. 一般要通过一个帮助函数来构造一个对象, 通过传递给帮助函数的参数推导出参数类型, 然后在帮助函数中返回一个构造好的对象. 下面介绍 C++17 之前的做法与 C++17 的便利性. 演示用的模板类 temp...
C++17之占位符类型作为模板参数
janeqi1987的专栏
09-05 1974
因为c++ 17可以使用占位符类型(auto和decltype(auto))作为非类型模板参数类型。这意味着，我们可以为不同类型的非类型参数编写通用代码。 1. auto作为模板参数 从c++ 17起，可以使用auto来声明一个非类型模板参数。例如: template<auto N> class S { ... }; 这允许我们为不同类型实例化非类型模板参数N: S&lt...
Dev-C++下基本数据类型学习小结
jx_kingwei的专栏
03-14 2308
环境: Dev-C++ 4.9.6.0 (gcc/mingw32), 使用-Wall编译选项基本类型包括字节型（char）、整型（int）和浮点型（float/double）。定义基本类型变量时，可以使用符号属性signed、unsigned（对于char、int），和长度属性short、long（对于int、double）对变量的取值区间和精度进行说明。下面列举了Dev-C++下基本类型所占位数
std::string的工具函数
热门推荐
边城客栈 - 学无止境
03-27 2万+
　　一般来说，在处理字符串的时候通常会用到如下一些函数／方法：length、substring、find、charAt、toLowerCase、toUpperCase、trim、equalsIgnoreCase、startsWith、endsWith、parseInt、toString、split等。　　如果使用STL中的std::string，它已经提供了如下一些比较有用的方法：leng
C++占位符
nike0good |Oier&ACMer | 熟能生巧
10-29 6951
%d 整数的占位符。可以是int short long的占位符。也可以是unsigned int ,unsigned short , unsigned long           %f 浮点数的占位符，包括float double           %s 字符串的占位符，一般字符串存到数组中，所以，字符串和数组经常联系到一起。           %c 字符的占位符，一个字符。char
C++-------类模板做函数参数
Allen_Xu17
01-13 1677
#include &lt;iostream&gt; #include &lt;string&gt; //注意头文件：string 和 string.h 的区别； using namespace std; //类模板做函数的参数： template&lt;class NameType, class AgeType&gt; class Person { public: Person(Nam...
C++11 新特性 ③ | 可变参数模板介绍
dvlinker的技术专栏
09-08 1万+
详细讲解C++11中的可变参数模板。
浅谈C++ templates 函数模板、类模板以及非类型模板参数
机器学习
12-22 2540
最近打算挑选几个STL容器做个简单实现，发现里面牵涉到不少模板知识。这里算提前学习一下C++模板的相关知识吧。这次主要学习了什么是函数模板（这个最简单），类模板以及非类型模板参数。下面挨个举例说明。 文章目录1. 函数模板2. 类模板3. 非类型模板参数 1. 函数模板 函数模板是最简答的一个，下面就定义一个返回两个值中最大者的函数模板： namespace og { template&amp;amp;lt;...
C++ 占位符
最新发布
qq_41184334的博客
10-22 325
格式占位符(%)是在C/C++语言中格式输入函数，如 scanf、printf 等函数中使用。其意义就是起到格式占位的意思，表示在该位置有输入或者输出。占位符就是先占住一个固定的位置，等着你再往里面添加内容的符号，广泛用于计算机中各类文档的编辑。
C/c++占位符
weixin_46129834的博客
06-02 7545
https://www.runoob.com/note/26809 占位符就是先占住一个固定的位置，等着你再往里面添加内容的符号，广泛用于计算机中各类文档的编辑。 格式占位符(%)是在C/C++语言中格式输入函数，如 scanf、printf 等函数中使用。其意义就是起到格式占位的意思，表示在该位置有输入或者输出。 %d, %i 代表整数 %f 浮点 %s 字符串 %c char %p 指针 %fL 长log %e 科学计数 %g 小数或科学计数。 %a,%A 读入一个浮点值(仅C99有效)。 %c 读入一
C/C++中的占位符
一缕阳光的博客
07-24 2835
在C++、c语言中增加了占位符，目的是为了减少内存的使用，但是现在内存已经不是瓶颈了，进而很少用占位符了 union V { struct X { unsigned char s1:2; unsigned char s2:3; unsigned char s3:3; } x; unsigned char c; } v; v.c = 100; printf("%d", v.x.s3); 分析： 十进制100对应的二进制为: 01100100 使用了占位符,二进制表示为： s..
C++占位符讲解
qq_40544338的博客
12-07 3683
一、目的 1、 二、参考 1、C++占位符讲解 https://blog.csdn.net/yubing841026/article/details/11257655 总结：good：知道了8、10、16进制表示；各种长度的占位符
C++11新特性应用--占位符(std::placeholders std::is_placeholder std::is_bind_expression)
zdy0_2004的专栏
01-07 1247
http://blog.csdn.net/wangshubo1989/article/details/50471709 上一篇博客讲了std::function和std::bind的使用，其中提到了占位符，std::placeholders 定义如下： namespace placeholders { extern /* unspecified */ _1; ex
c语言，c++语言中常用的一些占位符：%d，%f，%p，%s，%c等的含义及其解释
m0_62278731的博客
07-27 1万+
mf：输出的数据占m列，如字符串本身长度大于m，则突破获m的限制，将浮点型对象全部输出。%ms：输出的字符串占m列，如字符串本身长度大于m，则突破获m的限制，将字符串全部输出。%-m.nf：其中m，n含义同上，m为输出的宽度，n为保留小数位数，若浮点型对象长小于m，则在m列范围内，m前为负，浮点型对象左对齐，右补空格。%-mf：如果浮点型对象的长度小于m，则在m列范围内，m前为负，浮点型对象左对齐，右补空格。%m.ns：输出占m列，但只取字符串中左端n个字符，这n个字符输出在m列的右侧，左补空格。
C++常用占位符(自用)
qq_42751379的博客
07-14 7237
%d, %i 代表整数(bool类型也可以用%d) %f 浮点 %s 字符串 %c char %p 指针 %fL 长log %e 科学计数 %g 小数或科学计数 %a,%A 读入一个浮点值(仅C99有效) %c 读入一个字符 %d 读入十进制整数 %i 读入十进制，八进制，十六进制整数 %o 读入八进制整数 %x,%X 读入十六进制整数 %s 读入一个字符串，遇空格、制表符或换行符结束 %f,%F,%e,%E,%g,%G 用来输入实数，可以用小数形式或指数形式输入 %p 读入
【c++知识补充3】占位符 std::placeholders::_N
m0_61822314的博客
11-25 830
c++占位符_1,_2用法
C++入门，内联函数和默认参数还有函数占位符
qq_36983177的博客
02-08 431
// inline内联函数.cpp : 定义控制台应用程序的入口点。 //1.内联函数必须和函数体写在一起，只声明C++编译器不会报错，但也不会把它视为内联函数 //2.内联函数在最终生成的代码中是没有定义的 //3.C++编译器会把函数体直接插入到函数调用的地方 //4.内联函数没有普通函数的开销（压栈，跳转，返回等等） //5.内联函数是一种请求，C++编译器不一定同意 //6.内联函数不能存
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

-西门吹雪

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值