标签: auto

由于auto和decltype都用于推断类型.我以为他们会一样的.

但是,这个问题的答案表明不然.

我仍然认为他们不可能完全不同.我可以想到一个简单的例子,其中i两种情况下的类型相同.

auto i = 10; and decltype(10) i = 10;

那么auto和decltype行为相同的可能情况是什么呢？

我有一个二维地图,我这样说:

typedef std::map<std::string, std::map<std::string, Objective>> objectives_t;

我想将这个2d地图的内容保存到文件中.

所以我尝试了类似的东西,受到我在网络上找到的一些代码的启发:

for (auto const &subject : m_objectives) {
    for (auto const &objective : m_objectives[subject.first]) {
        //Print the objective
    }
}

但是,当然,这不起作用.我该怎么办？我不确定什么是主题和目标(他们是一些迭代器吗？).

在第二行,我得到:

error: passing 'const objectives_t {aka const std::map<std::basic_string<char>, std::map<std::basic_string<char>, Objective> >}' as 'this' argument of 'std::map<_Key, _Tp, _Compare, _Alloc>::mapped_type& std::map<_Key, _Tp, _Compare, _Alloc>::operator[](const key_type&) [with _Key = std::basic_string<char>; _Tp = std::map<std::basic_string<char>, Objective>; _Compare = std::less<std::basic_string<char> >; _Alloc = std::allocator<std::pair<const std::basic_string<char>, std::map<std::basic_string<char>, Obj|

考虑以下程序:

#include <iostream>
int main()
{
    int n = 3;
    int fact = 1;
    for(auto i{1};i<=n;i++)
        fact*=i;
    std::cout<<"fact of "<<n<<" is "<<fact;
}

即使我使用-std=c++14选项,它也可以在ideone上编译.在这里查看现场演示.但是在C++ 14中,变量i应该initializer_list根据此推断出来.

有一个C++ 1z的提议,它为括号初始化实现了新的类型推导规则:

对于直接列表初始化:

1. 对于只包含单个元素的braced-init-list,自动扣除将从该条目中推断出来;

2. 对于具有多个元素的braced-init-list,自动扣除将是不正确的.

[例:

auto x1 = {1,2}; // decltype(x1)是std :: initializer_list

auto x2 = {1,2.0}; //错误:无法推断出元素类型

auto x3 {1,2}; //错误:不是单个元素

auto x4 = {3}; // decltype(x4)是std :: initializer_list

auto x5 {3}; // decltype(x5)是int.

- 结束例子]

所以,规则改变了C++ 17.因此,当我使用时,程序不应该编译-std=c++14.这是g ++中的错误吗？这个变量不应该i像 …

通过在c ++ 11中添加'auto'-keyword,我想知道是否有可能'复制'另一个变量的类型,或函数的返回类型.

例如,在此代码中:

unsigned short x;
[...] // x is initialized with some value
for(auto i=0;i<x;i++)
{
    [...]
}

我会是一个int.是否有可能给我与x相同的类型,而不是手动将其声明为'unsigned short'？

基本上,我正在寻找的是:

[...]
for(type(x) i=0;i<x;i++)
[...]

嗨，stackoverflow 的人们，

我一直想知道是否有任何简单的方法：迭代器控制范围的 for 循环在访问它时从其容器中正确擦除对象；使用自动它。

对于标准的索引控制的 for 循环，我会做这样的事情：

void del(int i){
    cout<<"Deleting: "<<myObjects[i]<<':'<<myObjects[i]->c<<endl;
    for(unsigned int j = 0; j < allObjects.size();){
        if(allObjects[j] == myObjects[i]){
            delete allObjects[j];
            allObjects[j] = 0;
            allObjects.erase(allObjects.begin()+j);
            break;//Found and deleted first instance, escaping for-loop.
        }else{
            ++j;
        }
    }
    myObjects[i]=0;
    myObjects.erase(myObjects.begin()+i);
}

自动 for 循环看起来像这样：

void del(int i){
    cout<<myObjects[i]<<endl;
    for(auto it: allObjects)
        if(it == myObjects[i]){
            delete it;
            it = 0;
            //allObjects.erase();// Found, needs erasing.
        }
    myObjects[i]=0;
    myObjects.erase(myObjects.begin()+i);
}

我一直无法正确解决这个问题，并且一直在求助于旧式索引（使用索引的多种方法）。

我可以删除它，并将其设置为 0，但是如何在不知道索引的情况下从向量中删除它，并且可能在向量中删除它？我知道我可以跟踪循环并使用计数器来做到这一点，但这会破坏使用干净的迭代器循环的目的。

如果不在向量中删除，除了重新访问向量之外，我之后如何以轻松的方式进行处理？

使用索引驱动的 for 循环没有错，只是想知道是否有使用我们的新朋友“auto it”的简单替代方法。 …

在进行代码维护时,我找到了这样的代码:

auto networkEntry = _networkEntries[key];
networkEntry.port = port;
networkEntry.scope = scope;

用于的地图数据类型_networkEntries有两个重载版本operator[]:

template<class T>
class Map {
    // ... simplified STD compatible container ...
    T & Map::operator[](const Key & key);
    const T Map::operator[](const Key & key) const;
};

地图中使用的数据类型很简单struct.

现在我只是想知道,返回的值auto可以是数据结构的副本,也可以是对数据结构的引用.如果返回副本,则分配不会影响映射中的存储值.

我对这个案子有三个相关的问题:

• 我可以知道或测试operator[]使用的是哪个版本？
• 哪些C++规则适用于此处？
• 有没有办法,使用auto,以确保使用参考？

我有两个从类继承的类 Base

struct Base
{
   virtual ~Base() = default;
};

class Derived_1:public Base
{
  public:
     void getSomeFunc();
};

class Derived_2:public Base
{
  public:
     void getSomeFunc();
};

现在我想写一个函数，它接受基类指针对象并在动态转换后找到合适的孩子并返回它，以便我们可以调用正确版本的 getSomeFunc()

我试着写

auto getChild(Base* ptr)
{
  Derived_1 * p = dynamic_cast<Derived_1*>(ptr)
  if(p)
  {
    return p;
  }
  else
  {
      Derived_2 * q = dynamic_cast<Derived_2*>(ptr)
      if(q)
      {
        return q;
      }
     else
     { 
        // some handling to avoid bugs!!
     }
  }

但它没有被编译。任何方式来满足我的要求。

编辑 1 ----------------------------------
编译器的错误是 - incorrect deduction of 'auto'。编译是gcc

想象我有一个std::vectorof std::string，我想将它们转换std::string为std::string_view基于范围的 for 循环：

auto v = std::vector<std::string>{"abc", "def", "ghi"};
for (std::string_view sv : v) {
    // do something with string_view
}

上面的代码是完全有效的，但我想保留说明auto符来做到这一点，如何static_cast在一行基于范围的 for 循环中进行这样的操作？好像 C++20ranges可以以简洁的方式做到这一点，有人可以举个例子吗？

for (auto sv : v | static_cast<std::string_view>) {
    // do something with std::string_view
} 

我有以下类声明，根据我所了解的与 const 成员函数相关的知识，const 对象不能调用非常量成员函数。在 range-for 循环中，我们使用了“const auto animal”，它假设使用的是 const 对象，所以我认为在调用非常量成员函数 speak() 时，const 对象应该会给出编译错误，但它实际上编译，为什么？，也许我对 range-for 循环的真正工作方式没有明确的想法......谢谢！

#include <iostream>
#include <string>

class Animal {
protected:
     std::string name_;
     std::string speak_;
public:
    Animal(const std::string &name, const std::string &speak) : name_(name), speak_(speak){}
    const std::string &getName() const  { return name_;}
    std::string speak()  { return speak_;}
};

class Cat : public Animal{
public:
 Cat(const std::string &name) : Animal(name, "meow"){}
};

class Dog : public Animal{
public:
 Dog( const std::string &name) : Animal(name, "woof"){}
};

int main() { …

我正在从这篇文章中学习向量，它们从迭代器开始。他们定义 .begin 和 .end 如下：

begin() – 返回指向向量中第一个元素的迭代器

end() – 返回指向向量中最后一个元素之后的理论元素的迭代器

然后他们给出了以下代码片段，我添加了第三个 for 循环来表达我的问题。

#include<iostream>
#include<vector>

int main() {
    std::vector <int> g1; //creating a vector
    for (int i = 1; i <= 3; i++){
        g1.push_back(i);
    }
    std::cout << "Output of beginning and end values: ";
    for (auto i = g1.begin(); i != g1.end(); i++) {
        std::cout << *i << " "; 
    }
    std::cout << "\nOutput of beginning and end addresses: ";
    for (auto i = g1.begin(); i != …