标签: auto

我不确定以下语句有什么问题，它给了我编译错误。我们不能将“auto”与原子变量一起使用吗？

#include <iostream>
#include<future>
#include <atomic>
using namespace std;

int main()
{
  atomic<int> value(10);
  auto   NewValue = value;
}

但如果我用“int”替换“auto”，它就可以工作。为什么？

int main()
{
  atomic<int> value(10);
  int NewValue = value;
}

“auto”编译错误

 ||=== Build: Debug in Hello (compiler: GNU GCC Compiler) ===|
 F:\3d\C++CodeProject\Hello\main.cpp||In function 'int main()':|
 F:\3d\C++CodeProject\Hello\main.cpp|11|error: use of deleted function 
 'std::atomic<int>::atomic(const std::atomic<int>&)'|
C:\Program Files 
(x86)\CodeBlocks\MinGW\lib\gcc\mingw32\5.1.0\include\c++\atomic|612|note: 
declared here|
||=== Build failed: 1 error(s), 0 warning(s) (0 minute(s), 1 second(s)) ===|

在下面的代码片段中，函数B::f()是函数的“包装器” A::f()。但我假设A::f()返回类型是一种“不透明”类型，我不知道它是否具有值或引用语义。所以我不能使用autoorconst auto &作为 的返回类型B::f()。我认为这auto &&可以解决问题，但它并不像auto &&推断的那样A::OpaqueType &......这里是否可以避免写作A::OpaqueType？

#include <iostream>

struct A {
    using OpaqueType=int; // But it could have been `const int &`

    OpaqueType f() const {
        return i;
    }

    int i=42;
};

struct B {
    // how could I use `auto` here to avoid writing the `A::OpaqueType`?
    // I would have expected that `auto &&` would do the trick …

我正在关注这个教程。main.cc中的以下声明引起了我的兴趣：

auto say_hello = [](const HttpRequest& request) -> HttpResponse {
    HttpResponse response(HttpStatusCode::Ok);
    response.SetHeader("Content-Type", "text/plain");
    response.SetContent("Hello, world\n");
    return response;
}

这显示在调试窗口中。

auto我希望用原始数据类型替换关键字。我已尝试以下操作但失败：

HttpResponse say_hello = [](const HttpRequest& request) -> HttpResponse {...}

有人能告诉我为什么这是错误的吗？正确的解决方案是什么？太感谢了！！！

我读过有关自动变量和局部变量的内容；我知道我可以使用auto来声明局部变量，但我知道我只能在没有auto关键字的情况下声明/定义局部变量。

我读到，在C11之前，auto关键字是无用的，而在C11之后，auto关键字现在具有类型推断功能。

我使用 C99，我注意到这个版本的标准没有类型推断属性，因为如果我有这行代码：

...
auto x;
printf("%d",sizeof(x));
...

输出始终为 (4)，即使使用 1.5 初始化“x”也是如此。

我的问题是，auto关键字在C11之前有相关用途吗？

并且，在C11之后， auto关键字的“类型推断”属性有什么好处？在C11之后使用auto相关或重要的地方在哪里？

提前致谢！！

我收到了一个编译错误:

error: unable to deduce ‘auto*’ from ‘0l’

在尝试编译我的代码时:

random_device rd;
minstd_rand gen0(rd());
knuth_b gen1(rd());
ranlux24_base gen2(rd());

auto * generator = NULL; // error

switch(generatortmp) {
    case 0: generator = &gen0;
    more cases...
}

我该如何解决这个问题？

我试图auto &在ranged for循环中使用来修改值.但是我感到非常震惊,以至于它"无所不及".我附上下面的原始代码.它只是在矩阵中找到元素0,并将相应的行和列设置为全零.

    #include<iostream>
    #include<vector>
    using namespace std;

    void zerolify(vector<vector<int>>& m)
    {
        int row=m.size();
        int col=col>0?m[0].size():0;

        vector<int> r(row,0);
        vector<int> c(col,0);

        for(int i=0;i<row;i++)
        {
            for(int j=0;j<col;j++)
            {
                if(m[i][j]==0)
                {
                    r[i]=1;
                    c[j]=1;
                }
            }
        }

        for(int i=0;i<row;i++)
        {
            if(r[i])
            {
                //cout<<"row: "<<i<<endl;
                for(auto &e : m[i])
                {
                    e=0;
                }
                //for(int j=0;j<col;j++)
                //{
                //  m[i][j]=0;
                //}
            }
        }
        for(int i=0;i<col;i++)
        {
            if(c[i])
            {
                for(int j=0;j<row;j++)
                {
                    m[j][i]=0;
                }
            }
        }
    }
    void printMatrix(vector<vector<int>> m)
    {
        for(auto i:m)
        {
            for(auto j:i)
            { …

如果我使用这条路线：

Route::resource('monitor', 'UserMonitorController');

然后在控制器中：

public function update(Request $request, UserMonitor $userMonitor) {}

由谁自动生成

php artisan make:model -mcr UserMonitor

该$userMonitor是空的

我想返回多个值并使用 声明该函数auto。

但这效果并不好。无法正确返回值。它被覆盖了。

我尝试执行以下功能f1〜f3。这些函数应该返回元组中的向量和字符串。但只是f3效果很好。

#include <iostream>
#include <vector>
#include <string>
#include <tuple>

auto f1(){
    std::vector<double> v(10, 0);
    std::string s = "hello";
    return std::forward_as_tuple(v, s);
}

auto f2(){
    std::vector<double> v(10, 0);
    return std::forward_as_tuple(v, "hello");
}

std::tuple<std::vector<double>, std::string> f3(){
    std::vector<double> v(10, 0);
    std::string s = "hello";
    return std::forward_as_tuple(v, s);   
}
int main(void){
    //change the function
    //auto [vec, str] = f1();
    //auto [vec, str] = f2();
    auto [vec, str] = f2();

    for (auto e : …

为什么基于范围的循环没有auto显示地址？该for循环:

for (int i = 0; i < s; i++) cout << &ar[i] << endl; 

工作正常,但基于范围的循环auto不会:

#include <iostream>
#include <algorithm>
using namespace std;
int main() {
    int ar[] = { 12,-23,0,1,2 };
    int s = sizeof(ar) / sizeof(int);
    int * m = &ar[0];
    sort(&ar[0], m+ s);
    for (auto m : ar)
        cout << m << endl;
    cout << endl;
    for (auto m : ar)
        cout << &m << endl;
    cout << endl;
    for (int …

我必须将一个int和一个函数对象返回给调用者,我被认为是返回一个元组,就像make_tuple(int,[](some){})我现在在GCC上那样不支持decltpe(auto)作为返回类型,无论如何我std::tuple<int,auto> myfun()现在可以使我的返回类型我一直在做以下(但不确定)

auto myfun()->decltype(make_tuple(100,p))
{
   auto p=[](some){};
   return make_tuple(100,p);
}

我在做什么好吗？

auto data = new char[480][640][3]();
char data = new char[480][640][3]();

第一个作品。第二个没有。为什么？auto 不是应该用初始化器的类型替换自身吗？

既然auto关键字是在c ++ 11中引入的,我认为我们应该能够删除指定auto并简单地将变量初始化为v = 20.由于C++能够自己推断变量的类型,为什么不将auto关键字全部放在一起,并在第一次初始化时推导出变量的类型.

即代替

int main() {
    auto v = 20;
}

为什么不说

int main() {
    v = 20;
}

(假设没有与全局变量冲突,因为python对这种情况很好)