STL与泛型编程<十八>：STL算法之非变动性算法（Nonmodifying algorithm）

最新推荐文章于 2020-12-17 15:07:35 发布
最新推荐文章于 2020-12-17 15:07:35 发布
阅读量450 收藏 1
点赞数
分类专栏： C++学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/MonroeD/article/details/51089043
版权

1.元素计数(count和count_if)

count声明：

template <class InputIterator, class T>
typename iterator_traits<InputIterator>::difference_type //返回值 
count (InputIterator first, InputIterator last, const T& val)
{
    typename iterator_traits<InputIterator>::difference_type ret = 0;
    while (first!=last) 
    {
        if (*first == val) 
        ++ret;
        ++first;
    }
    return ret;
}
/*
可知返回值型别是difference_type，表现迭代器间距的型别
*/

count_if声明如下

template <class InputIterator, class UnaryPredicate>
typename iterator_traits<InputIterator>::difference_type
count_if (InputIterator first, InputIterator last, UnaryPredicate pred)
{
    typename iterator_traits<InputIterator>::difference_type ret = 0;
    while (first!=last) 
    {
        if (pred(*first)) 
            ++ret;
        ++first;
    }
    return ret;
}

使用如下

int val[] = {1,2,3,4,5,6};
vector<int> col(val,val+6);
int cnt = count(col.begin(),col.end(),4); //1
cnt = count_if(col.begin(),col.end(),bind2nd(greater<int>(),4));//3

2.最小值和最大值（max_element）

max_element声明

template <class ForwardIterator>
ForwardIterator max_element (ForwardIterator first, ForwardIterator last);//默认以operator < 进行比较

template <class ForwardIterator, class Compare>
ForwardIterator max_element (ForwardIterator first, ForwardIterator last, Compare comp);

等效于

template <class ForwardIterator>
ForwardIterator max_element ( ForwardIterator first, ForwardIterator last )
{
    if (first==last)
        return last;
    ForwardIterator largest = first;

    while (++first!=last)
    {
        if (*largest<*first)    // or: if (comp(*largest,*first)) for version (2)
            largest=first;
    }
    return largest;
}

使用如下

#include <iostream>     // std::cout
#include <algorithm>    // std::min_element, std::max_element

bool myfn(int i, int j) { return i<j; }

struct myclass {
  bool operator() (int i,int j) { return i<j; }
} myobj;

int main () 
{
    int myints[] = {3,7,2,5,6,4,9};

  // using default comparison:
    std::cout << "The smallest element is " << *std::min_element(myints,myints+7) << '\n';
    std::cout << "The largest element is "  << *std::max_element(myints,myints+7) << '\n';

  // using function myfn as comp:
    std::cout << "The smallest element is " << *std::min_element(myints,myints+7,myfn) << '\n';
    std::cout << "The largest element is "  << *std::max_element(myints,myints+7,myfn) << '\n';

  // using object myobj as comp:
    std::cout << "The smallest element is " << *std::min_element(myints,myints+7,myobj) << '\n';
    std::cout << "The largest element is "  << *std::max_element(myints,myints+7,myobj) << '\n';

    return 0;
}

3.搜寻元素(find和find_if）

1.搜寻第一个匹配元素

find声明如下

template<class InputIterator, class T>
InputIterator find (InputIterator first, InputIterator last, const T& val)
{
    while (first!=last) 
    {
        if (*first==val) return first;
        ++first;
    }
    return last;
}

find_if声明如下

template<class InputIterator, class UnaryPredicate>
InputIterator find_if (InputIterator first, InputIterator last, UnaryPredicate pred)
{
    while (first!=last) 
    {
        if (pred(*first)) return first;
        ++first;
    }
    return last;
}

使用如下

int val[] = {1,2,3,45,6};
vector<int> col(val,val+6);
vector<int>::iterator pos = find(col.begin(),col.end(),45);
if (pos != col.end()) 
{
    //found!
}
pos = find_if(col.begin(),col.end(),bind2nd(greater<int>(),2));

2.搜寻前n个连续匹配值（search_n）

search_n的声明：

template <class ForwardIterator, class Size, class T>
ForwardIterator search_n (ForwardIterator first, ForwardIterator last, Size count, const T& val); //返回第一组“连续count个元素全等于value”的元素位置的第一个元素

template <class ForwardIterator, class Size, class T, class BinaryPredicate>
   ForwardIterator search_n ( ForwardIterator first, ForwardIterator last, Size count, const T& val, BinaryPredicate pred );// 寻找pred(elem,val)为true的，返回意义同上

等效于

template<class ForwardIterator, class Size, class T>
ForwardIterator search_n (ForwardIterator first, ForwardIterator last, Size count, const T& val)
{
    ForwardIterator it, limit;
    Size i;

    limit=first; 
    std::advance(limit,std::distance(first,last)-count); //first只可能到limit位置

    while (first!=limit)//从头开始遍历
    {
        it = first; 
        i=0;
        while (*it==val)       // or: while (pred(*it,val)) for the pred version
        { 
            ++it; 
            if (++i==count) 
                return first; 
        }
        ++first;
    }
   return last;  //not found ,return last 
}

例子

// search_n example
#include <iostream>     // std::cout
#include <algorithm>    // std::search_n
#include <vector>       // std::vector

bool mypredicate (int i, int j) {
  return (i==j);
}

int main () 
{
    int myints[]={10,20,30,30,20,10,10,20};
    std::vector<int> myvector (myints,myints+8);

    std::vector<int>::iterator it;

    // using default comparison:
    it = std::search_n (myvector.begin(), myvector.end(), 2, 30);

    if (it!=myvector.end())
        std::cout << "two 30s found at position " << (it-myvector.begin()) << '\n'; //2
    else
        std::cout << "match not found\n";

    // using predicate comparison:
    it = std::search_n (myvector.begin(), myvector.end(), 2, 10, mypredicate);

    if (it!=myvector.end())
        std::cout << "two 10s found at position " << int(it-myvector.begin()) << '\n'; // 5
    else
        std::cout << "match not found\n";

    return 0;
}

关于search_n的第二种形式，请看以下调用

pos = seach_n(col.begin(),col.end(),4,3,greater<int>());//以这种方法来搜寻元素和以往的STL算法有些不同，以往的可能如下
pos = seach_n_if(col.begin(),col.end(),4,bind2nd(greater<int>(),3));

3.搜寻第一个子区间（search）

search声明

template <class ForwardIterator1, class ForwardIterator2>
ForwardIterator1 search (ForwardIterator1 first1, ForwardIterator1 last1, ForwardIterator2 first2, ForwardIterator2 last2);


template <class ForwardIterator1, class ForwardIterator2, class BinaryPredicate>
ForwardIterator1 search (ForwardIterator1 first1, ForwardIterator1 last1, ForwardIterator2 first2, ForwardIterator2 last2, BinaryPredicate pred);

/*
两种形式都返回区间[first1,last1)内和区间[first2,last2)完全吻合的第一个自区间内的第一个元素位置，如果没有找到都返回last1
*/

其等效于

template<class ForwardIterator1, class ForwardIterator2>
ForwardIterator1 search ( ForwardIterator1 first1, ForwardIterator1 last1,
                            ForwardIterator2 first2, ForwardIterator2 last2)
{
  if (first2==last2) return first1;  // specified in C++11

  while (first1!=last1)
  {
    ForwardIterator1 it1 = first1;
    ForwardIterator2 it2 = first2;
    while (*it1==*it2) {    // or: while (pred(*it1,*it2)) for version 2
        ++it1; ++it2;
        if (it2==last2) return first1;
        if (it1==last1) return last1;
    }
    ++first1;
  }
  return last1;
}

例子如下

#include <iostream>     // std::cout
#include <algorithm>    // std::search
#include <vector>       // std::vector

bool mypredicate (int i, int j) {
  return (i==j);
}

int main (void) 
{
    std::vector<int> haystack;

    // set some values:        haystack: 10 20 30 40 50 60 70 80 90
    for (int i=1; i<10; i++) 
        haystack.push_back(i*10);

    // using default comparison:
    int needle1[] = {40,50,60,70};
    std::vector<int>::iterator it;
    it = std::search (haystack.begin(), haystack.end(), needle1, needle1+4);

    if (it!=haystack.end())
        std::cout << "needle1 found at position " << (it-haystack.begin()) << '\n'; //3
    else
        std::cout << "needle1 not found\n";

    // using predicate comparison:
    int needle2[] = {20,30,50};
    it = std::search (haystack.begin(), haystack.end(), needle2, needle2+3, mypredicate);

    if (it!=haystack.end())
        std::cout << "needle2 found at position " << (it-haystack.begin()) << '\n';
    else
        std::cout << "needle2 not found\n";//needle2 not found

  return 0;
}

4.搜寻最后一个子区间(find_end)

find_end声明如下

template <class ForwardIterator1, class ForwardIterator2>
ForwardIterator1 find_end (ForwardIterator1 first1, ForwardIterator1 last1, ForwardIterator2 first2, ForwardIterator2 last2);

template <class ForwardIterator1, class ForwardIterator2, class BinaryPredicate>
ForwardIterator1 find_end (ForwardIterator1 first1, ForwardIterator1 last1, ForwardIterator2 first2, ForwardIterator2 last2, BinaryPredicate pred);
/*
两种形式都返回[first1,last1)之中和区间[first2,last2)完全吻合的最后一个子区间的第一个元素位置，否则返回last1
*/

等效于

template<class ForwardIterator1, class ForwardIterator2>
ForwardIterator1 find_end (ForwardIterator1 first1, ForwardIterator1 last1, ForwardIterator2 first2, ForwardIterator2 last2)
{
    if (first2==last2) return last1;  // specified in C++11

    ForwardIterator1 ret = last1;

    while (first1!=last1)
    {
        ForwardIterator1 it1 = first1;
        ForwardIterator2 it2 = first2;
        while (*it1==*it2) 
        {    // or: while (pred(*it1,*it2)) for version (2)
            ++it1; ++it2;
            if (it2==last2) { ret=first1; break; }
            if (it1==last1) return ret;
        }
        ++first1;
    }
    return ret;
}

例子如下

// find_end example
#include <iostream>     // std::cout
#include <algorithm>    // std::find_end
#include <vector>       // std::vector

bool myfunction (int i, int j) {
  return (i==j);
}

int main () {
  int myints[] = {1,2,3,4,5,1,2,3,4,5};
  std::vector<int> haystack (myints,myints+10);

  int needle1[] = {1,2,3};

  // using default comparison:
  std::vector<int>::iterator it;
  it = std::find_end (haystack.begin(), haystack.end(), needle1, needle1+3);

  if (it!=haystack.end())
    std::cout << "needle1 last found at position " << (it-haystack.begin()) << '\n'; // 5

  int needle2[] = {4,5,1};

  // using predicate comparison:
  it = std::find_end (haystack.begin(), haystack.end(), needle2, needle2+3, myfunction);

  if (it!=haystack.end())
    std::cout << "needle2 last found at position " << (it-haystack.begin()) << '\n';// 3

  return 0;
}

5.搜寻某些元素第一次出现的地点（find_first_of）

find_first_of 声明

template <class ForwardIterator1, class ForwardIterator2>
ForwardIterator1 find_first_of (ForwardIterator1 first1, ForwardIterator1 last1, ForwardIterator2 first2, ForwardIterator2 last2);

template <class ForwardIterator1, class ForwardIterator2, class BinaryPredicate>
ForwardIterator1 find_first_of (ForwardIterator1 first1, ForwardIterator1 last1, ForwardIterator2 first2, ForwardIterator2 last2, BinaryPredicate pred);//pred(*it1,*it2),其中it1是
/*
返回第一个既在[first1,end1)也在[first2,end2)出现的元素的位置(在[first1,end1)总的位置),失败返回last1
*/

其等效于

template<class InputIterator, class ForwardIterator>
InputIterator find_first_of ( InputIterator first1, InputIterator last1, ForwardIterator first2, ForwardIterator last2)
{
    while (first1!=last1) 
    {
        for (ForwardIterator it=first2; it!=last2; ++it) 
        {
            if (*it==*first1)          // or: if (pred(*first1，*it)) for version (2)
            return first1;
        }
        ++first1;
    }
    return last1;
}

例子如下

// find_first_of example
#include <iostream>     // std::cout
#include <algorithm>    // std::find_first_of
#include <vector>       // std::vector
#include <cctype>       // std::tolower

bool comp_case_insensitive (char c1, char c2) {
  return (std::tolower(c1)==std::tolower(c2));
}

int main () 
{
  int mychars[] = {'a','b','c','A','B','C'};
  std::vector<char> haystack (mychars,mychars+6);
  std::vector<char>::iterator it;

  int needle[] = {'A','B','C'};

  // using default comparison:
  it = find_first_of (haystack.begin(), haystack.end(), needle, needle+3);

  if (it!=haystack.end())
    std::cout << "The first match is: " << *it << '\n'; //A

  // using predicate comparison:
  it = find_first_of (haystack.begin(), haystack.end(),
                      needle, needle+3, comp_case_insensitive);

  if (it!=haystack.end())
    std::cout << "The first match is: " << *it << '\n';//a

  return 0;
}

6.搜寻两个连续相等的元素（adjacent_find）

adjacent_find声明如下

template <class ForwardIterator>
ForwardIterator adjacent_find (ForwardIterator first, ForwardIterator last);

template <class ForwardIterator, class BinaryPredicate>
ForwardIterator adjacent_find (ForwardIterator first, ForwardIterator last, BinaryPredicate pred);//pred(*it,*(it+1))

/*
返回第一个“两个连续相等的元素”中的第一个元素位置，失败返回last
*/

等效于

template <class ForwardIterator>
ForwardIterator adjacent_find (ForwardIterator first, ForwardIterator last)
{
    if (first != last)
    {
        ForwardIterator next=first; 
        ++next;
        while (next != last) 
        {
            if (*first == *next)     // or: if (pred(*first,*next)), for version (2)
                return first;
            ++first; 
            ++next;
        }
    }
    return last;
}

使用如下

int val[] = {1,2,3,100,100,5};
vector<int> col(val,val+6);
vector<int>::iterator pos;
pos = adjacent_find(col.begin(),col.end()); //返回第一个100的位置 
pos = adjacent_find(col.begin(),col.end(),greater<int>()); //回第二个100的位置

区间的比较

1.检验相等性(equal)

equal声明

template <class InputIterator1, class InputIterator2>
bool equal (InputIterator1 first1, InputIterator1 last1, InputIterator2 first2);//判断区间[first1,last1)内的元素是否都和“以first2开头的区间”的元素都相等

template <class InputIterator1, class InputIterator2, class BinaryPredicate>
bool equal (InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, BinaryPredicate pred);//pred(*it1,*it2)

等效于

template <class InputIterator1, class InputIterator2>
bool equal ( InputIterator1 first1, InputIterator1 last1, InputIterator2 first2 )
{
    while (first1!=last1) 
    {
        if (!(*first1 == *first2))   // or: if (!pred(*first1,*first2)), for version 2
            return false;
        ++first1; 
        ++first2;
  }
  return true;
}

例子如下

// equal algorithm example
#include <iostream>     // std::cout
#include <algorithm>    // std::equal
#include <vector>       // std::vector

bool mypredicate (int i, int j) {
  return (i==j);
}

int main () 
{
  int myints[] = {20,40,60,80,100};               //   myints: 20 40 60 80 100
  std::vector<int>myvector (myints,myints+5);     // myvector: 20 40 60 80 100

  // using default comparison:
  if ( std::equal (myvector.begin(), myvector.end(), myints) )
    std::cout << "The contents of both sequences are equal.\n"; //打印这行 
  else
    std::cout << "The contents of both sequences differ.\n";

  myvector[3]=81;                                 // myvector: 20 40 60 81 100

  // using predicate comparison:
  if ( std::equal (myvector.begin(), myvector.end(), myints, mypredicate) )
    std::cout << "The contents of both sequences are equal.\n";
  else
    std::cout << "The contents of both sequences differ.\n";// 打印这行 

  return 0;
}

2. 搜寻第一处不同点（mismatch）

声明如下

template <class InputIterator1, class InputIterator2>
pair<InputIterator1, InputIterator2> //返回值 
mismatch (InputIterator1 first1, InputIterator1 last1, InputIterator2 first2);

template <class InputIterator1, class InputIterator2, class BinaryPredicate>
pair<InputIterator1, InputIterator2>
mismatch (InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, BinaryPredicate pred);//pred(*it1,*it2)
/*
返回区间[first1,end1)和"以first2开头区间"之中第一组两两相异的对应元素
*/

等效于

template <class InputIterator1, class InputIterator2>
pair<InputIterator1, InputIterator2>
mismatch (InputIterator1 first1, InputIterator1 last1, InputIterator2 first2 )
{
  while( (first1!=last1) && (*first1==*first2) )  // or: pred(*first1,*first2), for version 2
  { 
    ++first1; 
    ++first2; 
  }
  return std::make_pair(first1,first2);
}

例子如下

// mismatch algorithm example
#include <iostream>     // std::cout
#include <algorithm>    // std::mismatch
#include <vector>       // std::vector
#include <utility>      // std::pair

bool mypredicate (int i, int j) {
  return (i==j);
}

int main () {
  std::vector<int> myvector;
  for (int i=1; i<6; i++) myvector.push_back (i*10); // myvector: 10 20 30 40 50

  int myints[] = {10,20,80,320,1024};                //   myints: 10 20 80 320 1024

  std::pair<std::vector<int>::iterator,int*> mypair;

  // using default comparison:
  mypair = std::mismatch (myvector.begin(), myvector.end(), myints);
  std::cout << "First mismatching elements: " << *mypair.first; // 30 
  std::cout << " and " << *mypair.second << '\n';// 80 

  ++mypair.first; 
  ++mypair.second;

  // using predicate comparison:
  mypair = std::mismatch (mypair.first, myvector.end(), mypair.second, mypredicate);
  std::cout << "Second mismatching elements: " << *mypair.first;// 40 
  std::cout << " and " << *mypair.second << '\n';// 320 

  return 0;
}
黑帽子和猫
关注
专栏目录
C++中argmin和argmax的实现
给永远比拿愉快
10-13 9907
C++中argmin和argmax的实现 在Python中argmin和argmax这两个函数一般是用来就一列数中的最小值和最大值的索引。C++中我们如何实现呢？ 实现思路 使用STL中的std::min_element函数求出最小值； 使用STL中的std::distance计算最小值跟迭代器的头部的距离； 实现代码 #include &lt;algorithm&gt; template&...
STL与泛型编程
11-22
STL（Standard Template Library，标准模板库...总之，STL与泛型编程是C++编程的重要组成部分，掌握了这两者，你将能编写出更加高效、灵活的代码。通过不断实践和学习，你将能够充分利用STL的优势，解决各种复杂问题。
STL： non-modifying algorithms
a130737的专栏
07-26 730
接下来， 我们主要介绍STL中的算法。
C++标准模板库——non-modifying algorithms
weixin_42464595的博客
04-25 169
#include<iostream> #include<vector> #include<algorithm> using namespace std; /* * STL Algorithm walkthrough * Non-modifying Algorithms *--- count,min,max,compare,linear search,attri...
C++中避免内存泄露常见的解决方式
weixin_33705053的博客
02-01 253
常见内存泄露及解决方式-选自ood启发录 new/delete, array new/arrray delete匹配 case 1: 在类的构造函数与析构函数中没有匹配地调用 new/delete！   解决方法：检查构造函数，在出现new的情况下，按相反的顺序在析构函数中匹配加入delete！ 这里有两个意思：      1〉new与delete匹配，array new/a...
C++ STL标准库：算法＜algorithm＞ 最小值min_element() 最大值max_element()的使用
超级大洋葱的博客
12-17 2766
#include <functional> #include <iostream> #include <vector> #include <algorithm> using namespace std; template <class T> void FillValue(T& vect, int first, int last) { if (last >= first) { for (int i = first; i &l
STL与泛型编程<十七>：STL算法简介及for_each()算法
耗纸的博客
04-06 2430
首先使用STL算法，有几个头文件需要说明下#include <algorithm> //算法 #include <numeric> //数值处理 #include <functional> //仿函数或函数适配器简介 所有的STL算法都用来处理一个或多个迭代器区间，第一个区间通常以起点和终点来表示，其他区间一般只需要提供起点就好； STL算法采用覆盖(overwrite)而非安
STL与泛型编程＜五＞：Sets和Multisets
耗纸的博客
03-07 807
set和multiset会根据特定的排序准则排序，自动将元素进行排序，不同之处在于multiset允许元素重复而set不允许。 其声明如下namespace std { template<class T, class Compare = less<T>, class Allocator = allocator<T> > class set; template<class
STL与泛型编程<六>：map和multimap
耗纸的博客
04-04 1680
Map和Multimap将key/value pair当作元素，进行管理。它们可根据key的排序准则自动将元素进行排序。其声明如下namespace std { template<class key, class T, class Compare = less<key>, class Allocator = allocator<pair<const Key, T> > >
STL与泛型编程<二>：Vector
耗纸的博客
03-06 539
Vector模拟一个动态数组，其内存模型如下 Vector的能力vector将元素复制到内部的dynamic array中，是一个有序群集；vector支持随机存取，vector迭代器是一个随机存取迭代器 ，所以对任何一个STL算法都可以。大小(size)和容量(capacity)为什么vector比容器的通用操作多了个capacity()？就是因为 vector优异性能就是配置比其容纳的元素所
泛型编程与STL.pdf
09-05
根据提供的文件信息，“泛型编程与STL.pdf”这一标题及描述主要聚焦于两个核心概念：泛型编程和标准模板库（Standard Template Library，简称STL）。这些是现代C++编程语言中的重要组成部分，对于软件开发人员来说...
朱老师C++课程第3部分3.3.STL的泛型算法使用详解
07-01
涵盖了C++基础语法和使用，面向对象，STL与泛型，Boost库和设计模式，C++编程优化技巧等非常广泛的内容，是市面上非常缺少的深度完整学习C++，培养编程技能和修养的一套系列学习课程。整个课程预计2020年底前录制...
stl常用算法(Algorithms)介绍(stl排序算法、非变序型队列)
09-04
在STL中，最常用的排序算法是`std::sort`，它位于`<algorithm>`头文件中。`std::sort`可以对任何随机访问迭代器范围内的元素进行排序，包括STL容器（如`vector`、`list`、`deque`）以及C风格的数组。以下是一个使用`...
C++ STL 和 泛型编程1
08-03
C++ STL，全称为Standard Template Library，是C++标准库的一部分，它提供了高效且灵活的容器、算法和迭代器等工具，便于实现泛型编程。泛型编程是一种编程范式，允许开发者编写不依赖特定数据类型的代码，从而提高...
C++避免编译警告unused
热门推荐
耗纸的博客
06-21 1万+
见 https://stackoverflow.com/questions/15763937/unused-parameter-in-c11#define UNUSED(expr) do { (void)(expr); } while (0)编译选项-Wall -Wextra -Werror -Wconversion -Wshadow
C++设计模式<五>：Observe观察者模式
耗纸的博客
04-09 1652
1.动机在软件构建过程中，我们需要为某些对象建立一种“通知依赖关系”——一个对象(目标对象)的状态发生改变，所有的依赖对象(观察者对象)都将得到通知。如果这样的依赖关系过于紧密，将使软件不能很好滴抵御变化2.模式定义定义对象间的一种一对多(变化)的依赖关系，以便当一个对象(object)的状态发生改变时，所有依赖于它的对象都得到通知并自动更新。3.例子看一个文件分割器的例子(以前磁盘小，经常需要文件
C++设计模式<六>：Decorator装饰模式
耗纸的博客
07-18 1543
“单一职责”模式 在软件组件的设计中，如果责任划分的不清晰，使用继承得到的结果往往是随需求的变化，子类急剧膨胀，同时充斥着重复代码，这时候的关键是划清责任。 典型模式 - Decorator - Bridge 1.动机在某些情况下我们可能会“过度地使用继承来扩展对象的功能”，由于继承为类型引入的静态特质，使得这种扩展方式缺乏灵活性；并且随着子类的增多(扩展功能的增多)，各种子类
C++设计模式<二>：面向对象设计原则
耗纸的博客
04-07 1391
面向对象设计变化是复用的天敌，而面向对象设计的最大优势就是抵御变化面向对象设计原则1.依赖倒置关系(DIP) 高层模块(稳定)不应该依赖于底层模块(变化)，二者都应该依赖于抽象(稳定) 抽象(稳定)不应该依赖于实现细节，实现细节应该依赖于抽象(稳定) 如上节 C++设计模式<一>：简介中的例子 其中MainForm(高层模块)应该是稳定的，而第一种方案(分解模式)却依赖于Lin
C++面向对象编程<六>：Big Three，三个特殊函数
耗纸的博客
02-22 1348
简介这里看class的另一个分类：class with pointer members. 先看String的声明#ifndef _MYSTRING_ #define _MYSTRING_class String { public: String(const char* cstr = 0); String(const String& str);
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值