小编Dan*_*iel的帖子

我正在练习c编程,但我遇到了一个我似乎无法弄清楚的问题.我有一个printf声明,其中包含两个不同int值的标记.无论第一个int是什么,它都会打印0,但第二个int打印正常.这是代码:

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

int a, temp;
int toBinary();
int toDecimal();

int main()
{
    char c;
    for(;;)
    {
        scanf("%d",&a);
        scanf(" %c",&c);
        switch(c)
        {
            case 'a' :
                printf("%d converted to binary: %d\n",a,toBinary());
                break;
            case 'b' :
                printf("%d converted to decimal: %d\n",a,toDecimal());
                break;
            case 'c' :
                printf("EXIT\n");
                return 0;
                break;
            default :
                printf("ERROR c value: %c\n",c);
                return 0;
        } 
    }
}
int toBinary()
{
    if (a == 0)
        return 0;
    else
    {
        temp …

我可以在 c 中初始化一维数组，无论是否初始化其大小：

int x[] = {1,2,3,4,5};
int y[5] = {1,2,3,4,5};

但是，当我尝试对二维数组执行相同操作时，例如

int x[][] = {{1,2,3},
             {4,5,6}};

我得到一个error: array type has incomplete element type. 如果我在不同的行声明和初始化数组，也会发生同样的错误。但是，我可以在指定大小的同时初始化它：

int x[2][3] = {{1,2,3},
               {4,5,6}};

这一点没有错误。我的问题是，是否可以在不首先初始化其大小的情况下初始化多维数组？我问这个问题是因为对于最终的项目，我需要能够声明数组并稍后初始化它们，并且在编译时将不知道它们的大小。

我正在按照 GLFW 指南开始，但我似乎无法让它与 GLAD 一起运行。

这是我的 C 文件 (prac.c)

#include <stdio.h>
#include <stdlib.h>
#include<glad/glad.h>
#include<GLFW/glfw3.h>

void error_callback(int error, const char* description) {
  fprintf(stderr, "Error %d: %s\n", error, description);
}

int main(void) {
  GLFWwindow* window;

  if(!glfwInit()) return -1;

  glfwSetErrorCallback(error_callback);

  glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
  glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 2);
  window = glfwCreateWindow(640, 480, "Hello World", NULL, NULL);
  if(!window) {
    glfwTerminate();
    return -1;
  } 

  glfwMakeContextCurrent(window);

  printf("OpenGL version: %s\n", glGetString(GL_VERSION));

  gladLoadGL();

  while(!glfwWindowShouldClose(window)) {
    glClear(GL_COLOR_BUFFER_BIT);

    glfwSwapBuffers(window);

    glfwPollEvents();
  }

  glfwDestroyWindow(window);
  glfwTerminate();
  return 0;
}

我通过运行以下命令的 Makefile 来编译它：

gcc -Wall -lglfw -lGL …

假设我有一个存储在a中的输入char c,并且在条件中我需要检查它是否是两个不同的字符,例如'n'和'N'.很明显,我可以使用逻辑OR运算符进行条件化:

if(c == 'n' || c == 'N')
...

但是,如果只有两个以上的条件,则需要使用更多的逻辑运算符,编写,查看和编辑将变得冗长乏味.有没有办法压缩这个过程？为了使它看起来像这样的东西:

if(c == '[N][n]')
...

有什么类似的存在吗？

采取两个相似的功能:

foo :: Eq a => [a] -> Bool
foo [x,y] | x == y = True
foo _ = False

bar :: Eq a => [a] -> Bool
bar _ = False
bar [x,y] | x == y = True

main = do
print $ foo [1,1]
print $ bar [1,1]

使用ghc编译时,结果是可预测的:

True

False

因为它似乎评估不同模式组的顺序从上到下.我的问题是这种行为是在语言本身还是仅由编译器定义的？例如,如果我使用不同的编译器,我会得到相反的结果吗？我想知道它是否像C/C++中那样可预测或模棱两可

当我想在Haskell中读取输入之前放入一些文本时,我尝试这样写:

putStr "enter value: "
var <- getLine

但是输出在显示文本之前需要用户输入:

[input]
enter value: 

当我使用putStrLn而不是putStr,它显示应该:

enter value: 
[input]

为什么这两个语句的功能不同？它是换行符的补充吗？