处理载体< int *>作为向量< const int *>无需复制（C ++ 0x） [英] Treat vector<int*> as vector<const int*> without copying (C++0x)

问题描述

类包含 std :: vector< int *> 。外部代码需要对这个向量进行只读访问，不应该能够修改内容（既不是指针也不能修改它们的内容）。在类中，值可以改变（例如 double_values（），因此将它们存储为 std :: vector< ; const int *> 是不可能的。

A class contains a std::vector<int*>. External code needs read-only access to this vector, should not be able to modify the contents (neither the pointers or their contents). Inside the class, the values may change (e.g. double_values(), and so storing them as a std::vector<const int*> is not possible.

是否有办法返回 std :: vector < int *> 作为一个 std :: vector< const int *> 没有做一个副本感觉像应该有，因为const

Is there a way to return the std::vector<int*> as a std::vector<const int*> without making a copy? It feels like there should be, because const is simply operating at compile time to say what can and cannot be modified.

代码：（使用编译g ++ -std = c + + 0x ）

Code: (compile with g++ -std=c++0x)

class ReadOnlyAccess
{
public:
  ReadOnlyAccess(const std::vector<int*> & int_ptrs_param):
    int_ptrs(int_ptrs_param)
  {
  }
  const std::vector<int*> & get_int_ptrs() const
  {
    return int_ptrs;
  }
  std::vector<const int*> safely_get_int_ptrs() const
  {
    // will not compile (too bad):
    //    return int_ptrs;

    // need to copy entire vector
    std::vector<const int*> result(int_ptrs.size());
    for (int k=0; k<int_ptrs.size(); k++)
      result[k] = int_ptrs[k];
    return result;
  }
  void double_values()
  {
    for (int*p : int_ptrs)
      *p *= 2;
  }
  void print() const
  {
    for (const int * p : int_ptrs)
      std::cout << *p << " ";
    std::cout << std::endl;
  }
private:
  std::vector<int*> int_ptrs;
};

int main() {
  ReadOnlyAccess roa(std::vector<int*>{new int(10), new int(20), new int(100)});
  std::vector<const int*> safe_int_ptrs = roa.safely_get_int_ptrs();
  // does not compile (good)
  // *safe_int_ptrs[0] = -100000;
  roa.print();

  const std::vector<int*> & int_ptrs = roa.get_int_ptrs();
  // changes are made to the internal class values via the accessor! nooooo!
  *int_ptrs[0] = -100000;
  roa.print();

  return 0;
}

推荐答案

返回向量将意味着

但是，如果你的目标是提供一个方法来使用这些值而不修改它们，或修改它的容器，那么，基于访问者模式的算法可能是一个非常好的解决方案，特别是现在我们可以使用lambda表达式：

However, if your goal is to provide a way to use the values without modifying them, or modifying it's container, then a visitor pattern based algorithm might be a very good solution, in particular now that we can use lambda expressions:

#include <vector>
#include <iostream>

class Data
{
public:

    //...whatever needed to fill the values

    // here we assume that Func is equivalent to std::function< void ( int )> or std::function< void (const int& ) > and can return anything that will be ignored here.
    template< class Func > 
    void for_each_value( Func func ) const // read-only
    {
        for( const int* value : m_values ) // implicit conversion
        {
             func( *value ); // read-only reference (const &), or copy
             // if func needs to work with the adress of the object, it still can by getting a reference to it and using & to get it's adress
        }
    }


    void print() const
    {
        std::cout << "\nData values: \n";
        for_each_value( []( const int value ) { std::cout << "    "<< value << '\n'; } );
    }

    void count_values() const { return m_values.size(); }

private:

    std::vector<int*> m_values;

};



int main()
{
    Data data;
    // ... whatever needed to fill the data

    data.print();    

    std::vector<int> modified_values;
    data.for_each_value( [&]( int value ) { modified_values.push_back( value + 42 ); } );

    return 0;
}

如果您理解，并且可以减少使用值的不同方法到几个半通用算法，那么它将使你的代码更简单，并允许你将数据保存在你的结构，而不是暴露它的勇气。

If you understand that, and the different ways to use the values can be reduced to a few half-generic algorithms, then it will make your code simpler and allow you to keep data inside your structures instead of exposing it's the guts.

这篇关于处理载体< int *>作为向量< const int *>无需复制（C ++ 0x）的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！