标签: definition

为什么是这样：

1. 函数定义可以使用在它之后定义的定义
2. 而变量定义不能。

例如，

a) 以下代码片段是错误的：

; Must define function `f` before variable `a`.
#lang racket
(define a (f)) 
(define (f) 10)

b) 虽然以下片段是正确的：

; Function `g` could be defined after function `f`.
#lang racket
(define (f) (g)) ; `g` is not defined yet
(define (g) 10)

C）右太：

; Variable `a` could be defined after function `f`
#lang racket
(define (f) a) ; `a` is not defined yet
(define a 10)

我正在开发 Linux Kernel 3.4，我有以下代码：

    /* Proximity sensor calibration values */
unsigned int als_kadc;
EXPORT_SYMBOL(als_kadc);
static int __init parse_tag_als_calibration(const struct tag *tag)
{
    als_kadc = tag->u.als_kadc.kadc;

    return 0;
}

__tagtable(ATAG_ALS, parse_tag_als_calibration);

但是当我构建它时，它给了我以下错误：

warning: data definition has no type or storage class [enabled by default]

是的，这是一个警告，但它是一个被禁止的警告，它被视为一个错误。警告指向代码中的以下行：

EXPORT_SYMBOL(als_kadc);

谁能帮我解决这个问题？

谢谢你。

struct Books
{
   char  title[50];
   char  author[50];
   char  subject[100];
   int   book_id;
} book;  

最后的“书”到底是什么？

我想要一种具有“全局预处理器定义”的方法，以便我可以在编译之前更改单个值以添加或删除程序的功能。目前我有一个“全局脚本”（称为 God.cs），其常量如下：

public const bool PRINT_RUN_VALUES = true;
public const bool DEBUG_MOVEMENT = false;
public const bool DOUBLE_SPEED = false;

所有相关脚本都使用这些值，例如：

在脚本1中：

if (God.PRINT_RUN_VALUES) {
   float averageDist = /* calculate values */
   print("Script1: averageDist = " + averageDist);
}

在脚本2中：

if (God.PRINT_RUN_VALUES) {
   print("Script2: radius = " + radius);
   print("Script2: time = " + time);
}

这种方法的问题是我得到了很多

CS0162：检测到无法访问的代码

警告。我可以使用以下方法关闭这些警告：

#pragma warning disable 0162
#pragma warning disable 0429

但我不想这样做，因为这些警告在不涉及 God.cs 中的这些值的情况下可能很有用。另一种方法可能是使用经典的预处理器定义，例如：

#define PRINT_RUN_VALUES
...
#if (PRINT_RUN_VALUES)
   float averageDist = /* calculate …

我不太确定我正在创建的对象类型的“名称”。我称其为树，因为它看起来类似于没有关系的嵌套树。本质上我想要一个具有嵌套定义的对象，如下所示

{
    test1: OptionsInterface,
    test2: {
        test3: OptionsInterface,
        test4: {
            test5: OptionsInterface,
        },
    },
}

因此，第一个级别可以是OptionsInterface或者{[s: string]: OptionsInterface}有没有办法在对象的每个“级别”上使用它？

我尝试像这样定义上面的内容：

export default class ApiClient {
    constructor(options: {[s: string]: OptionsInterface | {[s: string]: OptionsInterface}}) {}

但这只会是 2 深，对吗？有没有一种方法可以定义我的示例对象，而无需手动添加每个深度？

用例

我希望能够像这样打电话给我的班级

api = new ApiClient(routeSchema);
await api.call('test2.test4.test5', params);

通话中：

async call(config: string, variables: object = {}): Promise<Response> {
  const options = get(this.configuration, config);

  if (options === undefined) {
    throw new ConfigNotDefinedExpection(config);
  }

  return await this.callWithOptions(options, variables);
}

哪里callWithOptions …

我试图理解为什么当我使用 using 命名空间而不是显式声明命名空间外壳时，我的函数中存在歧义。

Book.h 头文件：

#ifndef MYBOOK_BOOK_H
#define MYBOOK_BOOK_H 

namespace mybook
{
    void showTitle();
    void showTableOfContents();
}

#endif

我的实现文件导致歧义错误：Book.cpp

#include "Book.h"
#include <iostream>
#include <cctype>
#include <cstring>

using namespace std;
using namespace mybook;

void showTitle() {
    cout << "The Happy Penguin" << endl;
    cout << "By John Smith" << endl;
}

void showTableOfContents() {
     cout << "Chapter 1" << endl;
     cout << "Chapter 2" << endl;
}

我的实现文件没有歧义错误：Book.cpp

#include "Book.h"
#include <iostream>
#include <cctype>
#include <cstring>

using namespace std;

namespace …

为什么这段代码返回 500 和一些垃圾值？为什么除法函数不起作用？

#include <stdio.h>

int divmul(int v1, int v2)
{
    int div,mul;
    div =v1/v2;
    mul=v1*v2;
    return div,mul;
}
main()
{
    int val1=50, val2=10;
    printf("%d %d\n", divmul(val1,val2));
}

我有一个函数，它需要一个变量和一个指针。

void sendCMD(byte cmd, byte data[]){
    ...
}

是否可以像这样以任何方式使用数据调用此函数

sendCMD(0xff, { 0x0a, 0x02 });

因为即使通过谷歌搜索我也没有找到任何东西......也许我看起来还不够努力，但我也不确定我应该寻找什么条款。任何帮助表示感谢！请注意，byte这与char!

我写了一个move模仿std::move，并尝试使用一个新的结构Foo来测试它。然而，发生了错误。

.\main.cpp: In function 'int main()':
.\main.cpp:46:7: error: conflicting declaration 'Foo x'
   46 |   Foo(x);
      |       ^
.\main.cpp:43:15: note: previous declaration as 'std::string x'
   43 |   std::string x = "123";
      |               ^

我替换代码Foo(x)用Foo foo = Foo(x)，那么一切都只是罚款。我正在使用MinGW32 g++ 9.2.0，用命令编译g++ main.cpp -std=c++14

有关更多详细信息，请参阅下面的代码：

#include <iostream>

template <class T>
struct Remove_Reference {
  typedef T type;
};

template <class T>
struct Remove_Reference<T&> {
  typedef T type;
};

template <class T>
struct …

我正在尝试以下...

#include <iostream>

using namespace std;

template<class T>
class Singleton
{
private:
    class InstPtr
    {
    public:
        InstPtr() : m_ptr(0) {}
        ~InstPtr() { delete m_ptr; }
        T* get() { return m_ptr; }
        void set(T* p)
        {
            if (p != 0)
            {
                delete m_ptr;
                m_ptr = p;
            }
        }
    private:
        T* m_ptr;
    };

    static InstPtr ptr;
    Singleton();
    Singleton(const Singleton&);
    Singleton& operator=(const Singleton&);

public:
    static T* instance()
    {
        if (ptr.get() == 0)
        {
            ptr.set(new T());
        }
        return ptr.get();
    }
};

class ABC
{ …