C警告：初始化使指针从整数而不进行强制转换[默认启用]

【问题标题】：C warning: initialization makes pointer from integer without a cast [enabled by default]C警告：初始化使指针从整数而不进行强制转换[默认启用]
【发布时间】：2016-07-10 12:55:16
【问题描述】：

所以，我有这个代码：

/*
*    CXenon VM v0.0.0
*/

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <stdbool.h>

#define IADD 1          // integer add
#define ISUB 2          // integer substract
#define IMUL 3          // integer multiply
#define IDIV 4          // integer divide
#define ILT 5           // integer less than
#define IEQ 6           // integer equals
#define BR 7
#define BRT 8
#define BRF 9
#define ICONST 10       // integer constant
#define LOAD 11         // load from data memory
#define GLOAD 12        // global load from data memory
#define STORE 13        // store in data memory
#define GSTORE 14       // global store in data memory
#define PRINT 15        // print
#define PRINTLN 16      // print with trailing newline
#define POP 17          // pop from stack
#define CALL 18         // call function
#define RET 19
#define FADD 20
#define FSUB 21
#define FMUL 22
#define FDIV 23
#define FCONST 24
#define FLT 25
#define FEQ 26
#define FMT 27
#define FNEQ 28
#define IMT 29
#define INEQ 30
#define BCONST 31
#define BEQ 32
#define BNEQ 33
#define BTRUE 34
#define BFALSE 35
#define HALT 36

char* opcodes[] = {
    "",
    "IADD",
    "ISUB",
    "IMULL",
    "IDIV",
    "ILT",
    "IEQ",
    "BR",
    "BRT",
    "BRF",
    "ICONST",
    "LOAD",
    "GLOAD",
    "STORE",
    "GSTORE",
    "PRINT",
    "PRINTLN",
    "POP",
    "CALL",
    "RET",
    "FADD",
    "FSUB",
    "FMUL",
    "FDIV",
    "FCONST",
    "FLT",
    "FEQ",
    "FMT",
    "FNEQ",
    "IMT",
    "INEQ",
    "BCONST",
    "BEQ",
    "BNEQ",
    "BTRUE",
    "BFALSE",
    "HALT"
};

struct stack_base{
    char* somechars;
    char achar;
    int anint;
    float afloat;
    bool abool;
};

int vm_cpu(struct stack_base* code, bool trace, int datasize){

    struct stack_base stack[100];
    struct stack_base data[datasize];

    int ip = 0; // instructionpointer
    int fp; // framepointer
    int sp = -1; // stackpointer
    int v;
    int addr;
    int nargs;
    int rvalue;
    int a, b;
    float fv;
    float fa, fb;
    bool bv;
    bool ba, bb;

    int opcode = code[ip].anint; // fetch
    int size = sizeof(code); // declares size of code
    //bool trace = false;

    while(ip < size){

        if(trace){
            printf("%04d: %s\n",ip, opcodes[opcode]); // prints trace
        }

        ip++;
        switch(opcode){
            case ICONST:
                v = code[ip].anint;
                ip++;
                sp++;
                stack[sp].anint = v;
                break;
            case ISUB:
                b = stack[sp--].anint;
                a = stack[sp--].anint;
                stack[++sp].anint = a - b;
                break;
            case IADD:
                b = stack[sp--].anint;
                a = stack[sp--].anint;
                stack[++sp].anint = a + b;
                break;
            case IMUL:
                b = stack[sp--].anint;
                a = stack[sp--].anint;
                stack[++sp].anint = a * b;
                break;
            case IDIV:
                b = stack[sp--].anint;
                a = stack[sp--].anint;
                stack[++sp].anint = a/b;
                break;
            case ILT:
                b = stack[sp--].anint;
                a = stack[sp--].anint;
                if(a > b){
                    stack[++sp].abool = true;
                    break;
                }
                else {
                    stack[++sp].abool = false;
                    break;
                }
            case IMT:
                b = stack[sp--].anint;
                a = stack[sp--].anint;
                if(a < b){
                    stack[++sp].abool = true;
                    break;
                }
                else {
                    stack[++sp].abool = false;
                    break;
                }
            case IEQ:
                b = stack[sp--].anint;
                a = stack[sp--].anint;
                if(a == b){
                    stack[++sp].abool = true;
                    break;
                }
                else {
                    stack[++sp].abool = false;
                    break;
                }
            case INEQ:
                b = stack[sp--].anint;
                a = stack[sp--].anint;
                if(a != b){
                    stack[++sp].abool = true;
                    break;
                }
                else {
                    stack[++sp].abool = false;
                    break;
                }
            case FCONST:
                fv = code[ip].afloat;
                ip++;
                sp++;
                stack[sp].afloat = fv;
                break;
            case FSUB:
                fb = stack[sp--].afloat;
                fa = stack[sp--].afloat;
                stack[++sp].afloat = fa + fb;
                break;
            case FADD:
                fb = stack[sp--].afloat;
                fa = stack[sp--].afloat;
                stack[++sp].afloat = fa + fb;
                break;
            case FMUL:
                fb = stack[sp--].afloat;
                fa = stack[sp--].afloat;
                stack[++sp].afloat = fa * fb;
                break;
            case FDIV:
                fb = stack[sp--].afloat;
                fa = stack[sp--].afloat;
                stack[++sp].afloat = fa/fb;
                break;
            case FEQ:
                fb = stack[sp--].afloat;
                fa = stack[sp--].afloat;
                if(fa == fb){
                    stack[++sp].abool = true;
                    break;
                }
                else {
                    stack[++sp].abool = false;
                    break;
                }
            case FLT:
                fb = stack[sp--].afloat;
                fa = stack[sp--].afloat;
                if(fa > fb){
                    stack[++sp].abool = true;
                    break;
                }
                else {
                    stack[++sp].abool = false;
                    break;
                }
            case FMT:
                fb = stack[sp--].afloat;
                fa = stack[sp--].afloat;
                if(fa < fb){
                    stack[++sp].abool = true;
                    break;
                }
                else {
                    stack[++sp].abool = false;
                    break;
                }
            case FNEQ:
                fb = stack[sp--].afloat;
                fa = stack[sp--].afloat;
                if(fa != fb){
                    stack[++sp].abool = true;
                    break;
                }
                else {
                    stack[++sp].abool = false;
                    break;
                }
            case BCONST:
                bv = code[ip].anint;
                ip++;
                sp++;
                if(bv == BTRUE){
                    stack[sp].abool = true;
                    break;
                }
                else if(bv == BFALSE){
                    stack[sp].abool = false;
                    break;
                }
            case BNEQ:
                bb = stack[sp--].abool;
                ba = stack[sp--].abool;
                if(ba == bb){
                    stack[++sp].abool = true;
                    break;
                }
                else {
                    stack[++sp].abool = false;
                    break;
                }
            case BEQ:
                bb = stack[sp--].abool;
                ba = stack[sp--].abool;
                if(ba != bb){
                    stack[++sp].abool = true;
                    break;
                }
                else {
                    stack[++sp].abool = false;
                    break;
                }
            case PRINT:
                v = stack[sp].anint;
                sp--;
                printf("%i", v);
                break;
            case PRINTLN:
                //v = stack[sp].anint;
                //fv = stack[sp].afloat;
                bv = stack[sp].abool;
                sp--;
                printf("%d\n", bv);
                break;
            case GLOAD:
                addr = code[ip].anint;
                ip++;
                v = data[addr].anint;
                sp++;
                stack[sp].anint = v;
                break;
            case GSTORE:
                v = stack[sp].anint;
                sp--;
                addr = code[ip].anint;
                ip++;
                data[addr].anint = v;
                break;
            case CALL:
                addr = code[ip++].anint;
                nargs = code[ip++].anint;
                stack[++sp].anint = nargs;
                stack[++sp].anint = fp;
                stack[++sp].anint = ip;
                fp = sp;
                ip = addr;
                break;
            case RET:
                rvalue = stack[sp--].anint;
                sp = fp;
                ip = stack[sp--].anint;
                fp = stack[sp--].anint;
                nargs = stack[sp--].anint;
                sp -= nargs;
                stack[sp++].anint = rvalue;
                break;
            case HALT:
                return 0;
                break;
        }
        opcode = code[ip].anint;
    }

}

void main(){
    struct stack_base hello[] = {
        BCONST, BTRUE,
        BCONST, BTRUE,
        BNEQ,
        PRINTLN,
        HALT
    };
    vm_cpu(hello, true, 4);
}

当我编译该代码时，出现以下错误：

thewatcher@thewatcher ~/Xenon/CXenon/src $ gcc main.c -o test
main.c: In function ‘main’:
main.c:402:9: warning: initialization makes pointer from integer without a cast [enabled by default]
         BCONST, BTRUE,
         ^
main.c:402:9: warning: (near initialization for ‘hello[0].somechars’) [enabled by default]
main.c:405:9: warning: initialization makes pointer from integer without a cast [enabled by default]
         PRINTLN,
         ^
main.c:405:9: warning: (near initialization for ‘hello[1].somechars’) [enabled by default]

我不明白为什么会发生这种情况，也不知道如何解决。有人可以帮我吗？

【问题讨论】：

  • 报错信息中有行号，为什么不检查呢？
  • void main() 应该是 int main(void)。 int size = sizeof(code); 是指针的大小，而不是元素的数量。
  • 我不熟悉你初始化结构数组的方式。但是当你在 main() 中初始化你的结构数组时。您使用 int 值（BCONST 等）对其进行初始化。但是结构中的第一个元素是“char* somechars”而不是 int。
  • 你希望struct stack_base hello[] = { BCONST, BTRUE, BCONST, BTRUE, BNEQ, PRINTLN, HALT };做什么？
  • 不，@mch 的更改不会消除任何错误消息。这就是为什么 mch 发表评论，而不是答案。您的代码中存在的问题比编译器抱怨的要多。

标签： c


【解决方案1】：

主函数中的结构成员初始化与结构定义不同。 你的结构成员应该像这样初始化。

struct stack_base hello[] = {
        {
            "hey there",'a',22,11,true
        },
        {
            "thank you",'b',11,11,false
        },
        {
            "hello",'c',11,11,true
        }
  };

还有下面一行，

int size = sizeof(code);

code 只是一个指向结构的指针，其大小始终为 4（旧系统）或 8（新系统）字节。我猜您正在尝试在 hello[] 结构数组中查找成员数。在这种情况下，您必须将此数字作为函数单独传递给vm_cpu 函数，或者使用一些逻辑在 vm_cpu 函数中确定此数字。 如果你不想通过不。成员作为参数，初始化mainfn中的结构如下：

struct stack_base hello[] = {
        {
            "abc",'a',11,11,true
        },
        {
            "abc",'a',11,11,true
        },
        {
            "abc",'a',11,11,true
        },NULL
};

而在vm_cpu函数中，使用下面的逻辑找出no。结构数组元素。

int size = 0;
    struct stack_base *ptr = code;

    while(ptr[size].somechars) {
        size++;
        ptr++;
    }
    size--;
    printf("The no. of elements of structure array: %d\n", size);

【讨论】：

    【解决方案2】：

    如果您正确初始化结构数组hello，您所面临的错误应该会消失。正如编译器告诉您的那样，您当前初始化它的方式非常令人困惑：

    警告：（'hello[0].somechars'的接近初始化）[默认启用]

    意味着你初始化结构体数组的方式有错误（see here 完全理解错误中涉及的语法）。你的第二个错误：

    警告：初始化使指针从整数而不进行强制转换

    编译器在初始化结构数组时也会感到困惑。以这个初始化为例：

    struct my_struct {
   int a;
   int b;
}
//Create a structure assigning the value of a to 10 and b to 20:
struct my_struct foo = {10, 20};

    这将初始化 一个 结构，而不是多个。如果你想使用类似的语法来创建结构数组，你可以这样做：

    //Use my_struct from the previous example
struct my_struct foo[] {
   {.a = 10, .b = 20},
   {.a = 1, .b = 2},
   {.a = 5, .b = 5}
};

    要进一步了解此语法，请参阅designated initializers。上面的语法为数组中的每个结构创建了一个包含这些成员的结构数组：

    foo[0].a = 10;
foo[0].b = 20;

foo[1].a = 1;
foo[1].b = 2;

foo[2].a = 5;
foo[2].b = 5;

    初始化struct stack_base hello[] 为每个成员设置这些值：

    //hello[0].somechars will be assigned the string "hello"
hello[0].achar = 'a';
hello[0].anint = 1;
hello[0].afloat = 1.0;
hello[0].abool = 0;

//hello[1].somechars will be assigned the string "bye bye"
hello[1].achar = 'b';
hello[1].anint = 2;
hello[1].afloat = 10.0;
hello[1].abool = 1;

    那么，你可以这样写：

    struct stack_base hello[] {
   {.achar = 'a', .anint = 1, .afloat = 1.0, .abool = 0},
   {.achar = 'b', .anint = 2, .afloat = 10.0, .abool = 1}
};

//Assign strings to achar
strcpy(hello[0].somechars, "hello");
strcpy(hello[1].somechars, "bye bye");

    在上面的示例中，不是为结构的每个成员分配精确的值，而是将分配给每个成员的分配替换为常量。例如，您可以将.anint = 1 替换为.anint = BCONST 等。

    然而，目前，它只是让您初始化结构数组的方式感到困惑。

    【讨论】：

    • @TheWatcher_...我很高兴能帮上忙！
    猜你喜欢
    • 1970-01-01
    • 2012-10-30
    • 2013-09-07
    • 2017-05-22
    • 2016-08-20
    • 1970-01-01
    • 2011-05-10
    相关资源
    最近更新 更多
    热门标签
    Java Python linux javascript Mysql C# Docker 算法 前端 SpringBoot Redis Vue spring 设计模式 .net core .net kubernetes c++ 数据库 数据结构 大数据 js 机器学习 微服务 Android Go 程序员 面试 JVM ASP.net core 云原生 人工智能 后端 PHP git CSS golang k8s Nginx Django mybatis 深度学习 多线程 React 架构 devops 爬虫 云计算 Spring Boot LeetCode