标签: implicit-declaration

这个:

const int a = 5;

编译得很好,而

const var a = 5;

没有......同时:

var a = 5;

编译就像这样:

int a = 5;

为什么？

我正在开发一个我们正在开发自己的RPC客户端的任务.编译我的服务器部分后,我收到以下警告:

implicit declaration of function 'read'
implicit declaration of function 'write'

我明白如果我要在主要的ex之后创建一个函数,我通常会收到此警告:

int main() {
    doSomething();
}

void doSomething() {
    ...
}

在上面的例子中,它应该抱怨我创建"doSomething"的功能.

为什么我的编译器会抱怨系统调用是隐式声明的,当它出现在main之前声明的函数中时？以下是系统调用的显示功能.

void Open(int connfd) {
/*Get message size*/
unsigned char temp[4] = { 0 };
int n = read(connfd, temp, 4);
if(n < 0) {/*On error*/
    perror("Read error");
    exit(1);
}/*End if*/
unsigned int msgSize = temp[0] +
    (temp[1] * 256) + 
    (temp[2] * 256 * 2) + 
    (temp[3] * 256 * 3);
printf("msgSize = %d\n", msgSize);

/*Allocate …

考虑以下类.

struct with_copy {
    with_copy() = default;
    with_copy(with_copy const&) {}
    with_copy& operator=(with_copy const&) { return *this; }
};

struct foo {
    with_copy c;
    std::unique_ptr<int> p;
};

• 是否with_copy有一个拷贝构造函数？是.它是明确定义的.
• 是否with_copy有一个移动构造函数？不可以.显式复制构造函数阻止生成它.
• 是否with_copy有删除的移动构造函数？不.没有移动构造函数与删除构造函数不同.删除的移动构造函数会尝试将格式错误而不是退化移动到副本.
• 可with_copy复制吗？是.其复制构造函数用于复制.
• 是with_copy可移动的？是.它的复制构造函数用于移动.

......现在是棘手的.

• 是否foo有一个拷贝构造函数？是.它有一个删除的,因为它的默认定义将由于调用unique_ptr已删除的复制构造函数而格式不正确.
• 是否foo有一个移动构造函数？GCC说是的,clang说没有.
• 是否foo有删除的移动构造函数？海湾合作委员会和铿锵声说不.
• 可foo复制吗？不会.它的复制构造函数被删除.
• 是foo可移动的？GCC说是的,clang说没有.

(当考虑赋值而不是构造时,行为类似.)

据我所知,海湾合作委员会是正确的.foo应该有一个移动构造函数,在每个成员上执行移动,在这种with_copy情况下退化为副本.Clang的行为似乎很荒谬:我有一个有两个可移动成员的聚合体,但我的聚合物是一个不可移动的砖块.

谁是对的？

为什么语言允许隐式声明函数和无类型变量？我知道C是旧的,但是允许省略声明和默认int()(或者int在变量的情况下)对我来说似乎并不那么理智,即便在那时.

那么,为什么它最初被引入？它真的有用吗？它实际上(仍然)使用过吗？

注意:我意识到现代编译器会给你警告(取决于你传递它们的标志),你可以抑制这个功能.那不是问题!

例:

int main() {
  static bar = 7; // defaults to "int bar"
  return foo(bar); // defaults to a "int foo()"
}

int foo(int i) {
  return i;
}

在思考这个问题时，我偶然发现了我不了解的其他内容。

标准说...

[class.dtor] / 4

如果类没有用户声明的析构函数，则将析构函数隐式声明为默认值。隐式声明的析构函数是其类的内联公共成员。

[class.dtor] / 10

[...]如果类具有带有虚拟析构函数的基类，则其析构函数（无论是用户声明的还是隐式声明的）都是虚拟的。

[class.dtor] / 7

默认使用但未定义为deleted的析构函数在使用odr时或在其首次声明后被明确默认为隐式定义。

[basic.def.odr] / 3

[...]如果虚拟成员函数不是纯函数，则将被使用。[...]

所以现在我想知道这段代码是否应该编译：

#include <memory>

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

struct Bar;
struct Foo : Base {
    std::unique_ptr<Bar> bar_{};
};

https://godbolt.org/z/B0wvzd

我认为~Foo()必须对其进行隐式定义，因为它是虚拟的，但由于Bar在此TU中不完整，因此无法编译。但是代码可以在所有主要的编译器中编译。

我想念什么？

下面给出的程序工作不包括<stdio.h>？为什么这样做？

int main()
{
    printf("integra");
    return 0;
}

考虑以下示例：

#include <iostream>

struct X
{
    X() = default;
    X(const X&) = default;
    X(X&&) = default;
    X& operator = (const X&) = default;
    X& operator = (X&&) = default;
};

int main()
{
    static_assert(std::is_nothrow_move_assignable_v<X>);

    return 0;
}

移动赋值运算符似乎是隐式的noexcept，因为静态断言通过了。

然而，超出范围的定义会使断言失败：

#include <iostream>

struct X
{
    X() = default;
    X(const X&) = default;
    X(X&&) = default;
    X& operator = (const X&) = default;
    X& operator = (X&&); //= default;
};

X& X::operator=(X&&) = default;

int main()
{
    static_assert(std::is_nothrow_move_assignable_v<X>);

    return …

以下程序是否Undefined Behaviour在C中调用？

int main()
{
    printf("Printf asking: Where is my declaration ?");
}

在上面的程序中有一个隐式声明printf(),上面的代码完全符合标准,还是只有一些特定于实现的行为？

我接受的答案读这里的是:

[a]不会为显式声明移动构造函数或移动赋值运算符的类生成复制构造函数和复制赋值运算符

我注意到(g ++ 4.7.2),如果你定义一个移动构造函数,它将与例如一起使用push_back(),而如果你所做的只是= delete复制构造函数,你就不会得到一个隐式移动构造函数 - 你得到一个错误. [...这让我想知道如果你没有明确地做任何事情,实际使用哪一个(移动或复制)...]

然而,本次网上参考不做出关于拷贝构造函数相同的明确承诺不会在定义转移构造函数被隐式定义.

所以我的问题是,标准保证的第一个报价(包括"或")？我宁愿,一些类这就需要一个明确的析构函数,只需移动构造函数和(删除)家移动运营商,完成"五规则",靠的是隐含的复制方法不被定义.如果我不能依赖它,那么我将不得不明确=delete它们 - 但这是很多潜在的冗余.

我经历了以下线程：

• 警告：函数的隐式声明
• C UNIX 中的隐式函数声明

可能我的问题是相关的。但是，虽然他们提供了应该在使用函数之前声明函数原型的解决方案，但我想探索当函数名称不匹配时会发生什么。在我的测试中，它仍然可以正常工作。

主 C 文件

#include "node.h"
int main(){
    nd *head=NULL;
    nd *tail=NULL;

    create_node(&head, &tail, 10);
    create_node(&head, &tail, 20);
    create_node(&head, &tail, 15);
    create_node(&head, &tail, 35);
    create_node(&head, &tail, 5);
    create_node(&head, &tail, 25);
    print_list(head, tail);
    create_node(&head, &tail, 55);
    create_node(&head, &tail, 52);
    create_node(&head, &tail, 125);

    printf("%d\n",tail->data);
    printf("%d\n",head->data);
    print_list(head, tail);
    return 0;
}

node.h 文件

#ifndef NODE_H
#define NODE_H

#include<stdio.h>
#include<stdlib.h>

typedef struct node{
    int data;
    struct node *next;
    struct node *prev;
}nd;

void insert_node(nd **head, nd **tail, int data); …