C++ C++；：将向量转换成子程序

在我的示例中，我想打印三个类似的向量。 你能帮我理解如何把向量转换成子程序，这样就不会 重复一遍

#include "stdafx.h";
#include <vector>;
#include <iostream>
#include <algorithm>
#include <iterator>

using namespace std;


struct SPoint
{   
    int X;
    int Y;
};

vector<SPoint> points;
vector<SPoint> selected;
vector<SPoint> cleared;

void print_points()
{
    cout << "Points: "<< endl;
    for (int i = 0; i < points.size(); i++)
    {
        cout << '('<<points[i].X <<',' <<points[i].Y <<')'<< endl;
    }
    cout << endl;
}

void print_selected()
{
    cout << "Selected: "<< endl;
    for (int i = 0; i < selected.size(); i++)
    {
        cout << '('<<selected[i].X <<',' <<selected[i].Y <<')'<< endl;      
    }
    cout << endl;
}

void print_cleared()
{
    cout << "Cleared: "<< endl;
    for (int i = 0; i < cleared.size(); i++)
    {
        cout << '('<<cleared[i].X <<',' <<cleared[i].Y <<')'<< endl;        
    }
    cout << endl;
}



int main ()
{
    SPoint temp = {0, 0};

    for (int i = 0; i < 11;i++)
    {
        temp.X = i;
        temp.Y = i;
        points.push_back(temp);

    }

    for (int i = 5; i< 11;i++)
    {
        temp.X = i;
        temp.Y = i;
        points.push_back(temp);
    }

    print_points();
    print_selected();
    print_cleared();

    system ("pause");

  return 0;
}

#包括“stdafx.h”；
#包括,；
#包括
#包括
#包括
使用名称空间std；
结构点
{   
int X；
int-Y；
};
矢量点；
选择载体；
向量清除；
无效打印点（）
{
cout要将向量作为参数传递给函数，请执行以下操作：

void func(const vector<SPoint>& points) {
  ... do stuff
}

  ...some stuff
  vector<SPoint> a;
  func(a);

void
print(const std::vector<SPoint>& vect, const std::string& message)
{
    std::cout << message << ":" << std::endl;
    for (int i = 0, size = vect.size(); i < size; ++i)
        std::cout << vect[i].X << ":" << vector[i].Y << " ";
    std::endl;
}

print(points, "Points");
print(points, "Selected");
print(points, "Cleared");

void函数（常量向量和点）{
…做事
}

然后在代码中调用函数，如下所示：

void func(const vector<SPoint>& points) {
  ... do stuff
}

  ...some stuff
  vector<SPoint> a;
  func(a);

void
print(const std::vector<SPoint>& vect, const std::string& message)
{
    std::cout << message << ":" << std::endl;
    for (int i = 0, size = vect.size(); i < size; ++i)
        std::cout << vect[i].X << ":" << vector[i].Y << " ";
    std::endl;
}

print(points, "Points");
print(points, "Selected");
print(points, "Cleared");

…一些东西
载体a；
func（a）；
要将向量作为参数传递给函数，请执行以下操作：

void func(const vector<SPoint>& points) {
  ... do stuff
}

  ...some stuff
  vector<SPoint> a;
  func(a);

void
print(const std::vector<SPoint>& vect, const std::string& message)
{
    std::cout << message << ":" << std::endl;
    for (int i = 0, size = vect.size(); i < size; ++i)
        std::cout << vect[i].X << ":" << vector[i].Y << " ";
    std::endl;
}

print(points, "Points");
print(points, "Selected");
print(points, "Cleared");

void函数（常量向量和点）{
…做事
}

然后在代码中调用函数，如下所示：

void func(const vector<SPoint>& points) {
  ... do stuff
}

  ...some stuff
  vector<SPoint> a;
  func(a);

void
print(const std::vector<SPoint>& vect, const std::string& message)
{
    std::cout << message << ":" << std::endl;
    for (int i = 0, size = vect.size(); i < size; ++i)
        std::cout << vect[i].X << ":" << vector[i].Y << " ";
    std::endl;
}

print(points, "Points");
print(points, "Selected");
print(points, "Cleared");

…一些东西
载体a；
func（a）；
只需对向量使用
常量
引用并将其传递给函数：

void print(const vector<SPoint> &data) const {

}

...

print(points);

void打印（常量向量和数据）常量{
}
...
打印（点数）；
只需对向量使用
常量
引用并将其传递给函数：

void print(const vector<SPoint> &data) const {

}

...

print(points);

void打印（常量向量和数据）常量{
}
...
打印（点数）；
您可以这样做：

void func(const vector<SPoint>& points) {
  ... do stuff
}

  ...some stuff
  vector<SPoint> a;
  func(a);

void
print(const std::vector<SPoint>& vect, const std::string& message)
{
    std::cout << message << ":" << std::endl;
    for (int i = 0, size = vect.size(); i < size; ++i)
        std::cout << vect[i].X << ":" << vector[i].Y << " ";
    std::endl;
}

print(points, "Points");
print(points, "Selected");
print(points, "Cleared");

void
打印（常量标准：：向量和向量，常量标准：：字符串和消息）
{
std：：cout您可以这样做：

void func(const vector<SPoint>& points) {
  ... do stuff
}

  ...some stuff
  vector<SPoint> a;
  func(a);

void
print(const std::vector<SPoint>& vect, const std::string& message)
{
    std::cout << message << ":" << std::endl;
    for (int i = 0, size = vect.size(); i < size; ++i)
        std::cout << vect[i].X << ":" << vector[i].Y << " ";
    std::endl;
}

print(points, "Points");
print(points, "Selected");
print(points, "Cleared");

void
打印（常量标准：：向量和向量，常量标准：：字符串和消息）
{
STD:：CUT
这里是一个完整的C++风格方法：
struct SPoint
{   
    int X;
    int Y;
};

std::ostream& operator <<( std::ostream& stream, SPoint const& point )
{
    stream << '(' << point.X << ',' <<point.Y << ')';
    return stream;
}

void print_vector( std::ostream& stream, std::vector< SPoint > const& vector )
{
    std::copy(
        points.begin(), points.end()
      , std::ostream_iterator< SPoint >( std::cout, '\n' )
    );
}

这里是一个完整的C++风格方法：
struct SPoint
{   
    int X;
    int Y;
};

std::ostream& operator <<( std::ostream& stream, SPoint const& point )
{
    stream << '(' << point.X << ',' <<point.Y << ')';
    return stream;
}

void print_vector( std::ostream& stream, std::vector< SPoint > const& vector )
{
    std::copy(
        points.begin(), points.end()
      , std::ostream_iterator< SPoint >( std::cout, '\n' )
    );
}

不要忘记OP的问题（有点加密，但仍然：
C++：将向量转换为子程序
）。您的答案并不表示您在调用函数时忘记传递流。不要忘记OP的问题（有点加密，但仍然：
C++：将向量转换为子程序
）。您的答案并不表示您在调用函数时忘记传递流。没有消息处理的方法吗？您的意思是什么？我们无法预测您要打印的标题！没有消息处理的方法吗？您的意思是什么？我们无法预测您要打印的标题！