相关疑难解决方法(0)

在C++中命名函数的惯例是什么？

我来自Java环境所以我通常命名为:

myFunction(...) {
}

我在C++中看过混合代码,

myFunction(....)
MyFunction(....)
Myfunction(....)

什么是正确的方法？

另外,对于类方法还是非类方法,它是一样的吗？

C++迭代器的典型示例是指针,可用于指向C数组中的元素,如下所示:

int array[] = {1, 2, 3, 4};
int* begin = std::begin(array); //Starting iterator
int* end = std::end(array) //Ending iterator

for(int* i = begin; i < end; i++)
{
    std::cout << *i << ',';
}

//Prints 1, 2, 3, 4

这很简单.来自cplusplus.com的迭代器的定义是

迭代器是指向一系列元素(例如数组或容器)中的某个元素的任何对象,它能够使用一组运算符迭代该范围的元素...

这是有道理的; 在上面的代码中有两个迭代器(begin和end迭代器),它使用一个for循环并递增.

在Rust中,迭代器的使用方式如下:

let vect = vec![1, 2, 3, 4];

let vect_iter = vect.iter();

什么？要迭代它,你可以:

vect_iter.next();
vect_iter.next();

我在Rust文档中找不到任何指针的确切定义,但是看一下该Iterator特性,似乎迭代器是容器的包装器,通过以某种方式标准化逻辑来实现更容易的处理(如果是一点都有意义.

我的主要问题是:

1. 有哪些主要区别？
2. 为什么Rust以这种方式拥有迭代器,为什么它们表达方式如此不同？
3. C++中是否有Rust类型的迭代器？
4. 是否有C++ - 在Rust中输入迭代器？
5. 它们被称为具体的东西吗？(内部外部？)

我正在尝试专注std::begin于自定义容器.我这样做是因为我想使用基于范围for的容器.这就是我所拥有的:

class stackiterator { … };
class stack { … };

#include <iterator>

template <> stackiterator std::begin(stack& S)
{
  return S.GetBottom();
}

我在我的begin专业化定义中遇到以下错误:

没有函数模板匹配函数模板特化"开始"

我究竟做错了什么？

我有一个这样的课:

class Foo {
private:
    int a,b,c,d;
    char bar;
    double m,n
public:
    //constructors here
};

我想在课堂上允许使用范围循环,例如

Foo foo {/*...*/};
for(auto& f : foo) {
  //f will be a specific order such as c,b,d,(int)m,(int)bar,a,(int)n
}

我怎样才能做到这一点？我在看迭代器,但不知道range-for循环的要求是什么.(请不要让我使用数组或STL类型)

有许多不同的方法可以使类型/类在范围 for 循环中可用。例如，在cppreference上给出了概述：

range-expression进行评估以确定要迭代的顺序或范围。序列中的每个元素依次被取消引用，并用于使用范围声明中给定的类型和名称来初始化变量。

begin_expr并end_expr定义如下：

• 如果range-expression是数组类型的表达式，则begin_expris__range 和end_expris ( __range+ __bound)，其中__bound是数组中元素的数量（如果数组大小未知或类型不完整，则程序格式错误）
• 如果是同时具有指定成员和指定成员的range-expression类类型的表达式（无论该成员的类型或可访问性如何），则is且isCbeginendbegin_expr__range.begin()end_expr__range.end()
• 否则，begin_exprisbegin(__range)和end_expris end(__range)，它们是通过参数相关的查找找到的（不执行非 ADL 查找）。

如果我想在函数模板中使用范围 for 循环，我想限制类型在范围 for 循环中可用，以触发编译器错误并显示一条漂亮的“约束不满足”消息。考虑以下示例：

template<typename T>
requires requires (T arg) {
  // what to write here ??
}
void f(T arg) {
    for ( auto e : arg ) {
    } …

我是新的C++编程和整个学期来containers举例,如vector,deque,map,等.

什么应该class满足container在C++中称为a 的最低要求？

我经常打包一些数据class以防止公共/全局访问出错,并提供一些常用方法,例如:

class GameArea{
    std::vector<Enemy*> enemies;
    std::wstring name;
public:
    void makeAllEnemiesScared();
    Enemy * getEnemy(unsigned index);
};

GameArea这只是一个简化的例子.它是一种带有一些专门方法的自定义容器/ menager(但它不仅仅是一个容器).

理想的情况是,当我知道将在每个操作上执行哪些操作Enemy时,它们会在几个地方发生,因此我可以GameArea直接声明它们(如makeAllEnemiesScared()).

对于其他情况,我可以使用:

for(unsigned i=0; i<gameArea->getEnemiesCount(); i++){
    Enemy * enemy = gameArea->getEnemy(i);
    ...
}

但它有一些缺点:

• 我不能使用C++ 11 clean&nice for(auto &Enemy : enemies)循环,
• 它没有效率(这么多的电话getEnemy(index)),
• getEnemy(index)迭代抛出所有元素并不是一个目的- 当我们想要选择单个或少数几个时,它也很有用,它也检查index < enemies.size()内部 - 在循环中的每个元素上检查它是很糟糕的.

注意:我考虑的情况是,当我做一些非常特殊的事情时(不值得创建单独的方法GameArea,但是在每个元素上GameArea::enemies).

我想过一些GameArea::onEachEnemy(... function ...)方法需要一个function(或者更好的lambda？)作为参数.那是好的解决方案吗？

或者可能 …

给定以下课程：

template<class T>
class A {
    vector<T> arr;
public:
    A(int size);
    A(vector<T> arr);
    int size() const;
    A& operator=(const A& p);

    template<class S>
    friend ostream& operator<<(ostream& os, const A<S>& p);

    template<class S>
    friend bool operator==(const A<S>& p1, const A<S>& p2);   
};

我如何为我的班级定义iterator和？const_iterator（我想使用向量的迭代器来实现class iteratorandclass const_iterator）..

我想（例如）支持类似的事情：

A a(5);  
for(A<int>::iterator it = a.begin() ; it != a.end() ; it++) { /* .. */ }

这个问题的原因是我见过这样的代码：

auto fun(std::vector<Foo>&& v) {\n    std::vector<Bar> w;\n    for (auto&& e : v /* not an rvalue, but keep reading */) {\n        w.push_back(std::move(e));\n    }\n    // do stuff with w\n}\n

静态分析工具将其标记为错误，因为转发引用e正在被std::moved 而不是被std::forwarded。

另一方面，v肯定绑定到纯右值或 xvalue（客户端知道是或想要fun将其视为临时值的东西），因为它的类型是右值引用。是的，我看到函数的主体没有以任何方式声明v在for，但这只会让我认为我应该改变

\n
• for (auto&& e : v)到for (auto&& e : std::move(v))，
\n
• 和auto&&，E&&假设类似using E = std::decay_t<decltype(v)>::value_type;。
\n

据我了解，第一点没有达到我预期的效果。事实上，std::move就目前而言，似乎没有任何影响for …

有没有办法对向量的一部分进行基于范围的循环？例如，我想遍历向量的前 5 个元素：

for(auto& elem : my_vector[0:5]) {  // Syntax obviously doesn't exist
  do_stuff(elem);
}

我可以按照How to make my custom type to work with "range-based for loops" 中指定的那样编写自己的容器？但我希望在 boost 或一些相关库中有更简单的方法。

C++20 似乎包括“范围”，但在 20 之前有没有类似的东西？