主页 / 问题

问题[c]

Martin Hope
Чёрный Монах
Asked: 2024-12-08 18:55:34 +0800 CST
  • 5

请解释我是否正确理解这个概念。

关于术语对齐的标准摘录：

要求特定类型的对象位于存储边界上，其地址是字节地址的特定倍数。

翻译：

要求特定类型的对象位于存储边界，其地址是字节地址的特定倍数。

我对此的理解是，内存中任何变量的值必须通过实现分布在整数个字节上，这意味着位字段小于一个字节的结构将占用一个或多个字节，对吗？

c
Martin Hope
jrfdsa
Asked: 2024-12-06 02:40:40 +0800 CST
  • 5

使用open62541编写的服务器，为什么只能通过localhost访问？

我尝试像这样添加服务器网址

UA_String serverUrls[2];
size_t serverUrlsSize = 0;

UA_String_clear(config.serverUrls);

serverUrls[serverUrlsSize] = UA_STRING("opc.tcp://:48440");
serverUrlsSize++;
serverUrls[serverUrlsSize] = UA_STRING("opc.tcp://192.9.200.93:48440");
serverUrlsSize++;

retval = UA_Array_copy(serverUrls, serverUrlsSize,
        (void**)&config.serverUrls, &UA_TYPES[UA_TYPES_STRING]);
if (retval != UA_STATUSCODE_GOOD)
{
    return retval;
}
config.serverUrlsSize = serverUrlsSize;

但没有任何帮助，所以我需要一个 lds 服务器来进行外部访问？

PS它不允许你创建标签，但是没有opcua和open62541标签

c
Martin Hope
Treeesk
Asked: 2024-12-05 02:54:26 +0800 CST
  • 5

我面临的任务是：练习 6.2。编写一个程序，读取 C 程序的文本，并按字母顺序打印所有变量名称组，其中前 6 个字符相同，但后续字符在某些方面有所不同。不要处理引用的字符串和注释的内部。将数字 6 设置为在命令行上指定的参数。我用更简化的版本解决了它，并简单地处理了输入到终端中的单词。我将它们全部放置为一棵大二叉树，其节点也是树，但具有相同的 N 个字母。我希望我的程序不输出那些包含一个单词的树，我该如何更改程序以使其正常工作。

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



struct tnode { /* узел дерева */
    char *word; /* указатель на текст */
    struct tnode *left; /* левый сын */
    struct tnode *right; /* правый сын */
    int count; // подсчет количества слов в узле
};


struct tree_of_trees {
    struct tnode *bin_tree;
    struct tree_of_trees *left_son;
    struct tree_of_trees *right_son;
};



/* talloc: создает tnode */
struct tnode *talloc(void)
{
    return (struct tnode *) malloc(sizeof(struct tnode));
}


char *strdup_(char *s) /* делает дубликат s */
{
    char *p;
    p = (char *) malloc(strlen(s)+1); /* +1 для '\0' */
    if (p != NULL)
        strcpy(p, s);
    return p;
}

/* addtree: добавляет узел со словом w в р или ниже него */
struct tnode *addtree(struct tnode *p, char *w)
{
    int cond;
    if (p == NULL) { /* слово встречается впервые */
        p = talloc(); /* создается новый узел */
        p->word = strdup_(w);
        p->left = p->right = NULL;
        p -> count = 1;
    }
    else if ((cond = strcmp(w, p -> word)) < 0){ /* меньше корня левого поддерева */
        p->left = addtree(p->left, w);
        p -> count++;
    }
    else if (cond > 0){ /* больше корня правого поддерева */
        p->right = addtree(p->right, w);
        p -> count++;
    }
    return p;
}

struct tree_of_trees *balloc(void)
{
    return (struct tree_of_trees *) malloc(sizeof(struct tree_of_trees));
}

char *skip_n(char *word, int n){
    return &word[n + 1];
}

char *check_n(char *word, int n){
    char *p, *w;
    p = w = word;
    for (int i = 1; i < n; i++)
        *++w = *(++word);

    return p;
}


struct tree_of_trees *big_tree(struct tree_of_trees *p, struct tnode *vet, int n){
    int cond;
    if (vet == NULL) return p;
    if (p == NULL){
        p = balloc();
        p->bin_tree = vet;
        p->left_son = p->right_son = NULL;
    }
    if (strcmp(check_n(vet->word, n), check_n(p -> bin_tree -> word, n)) == 0){ 
        if ((cond = strcmp(skip_n(vet->word, n), skip_n(p -> bin_tree -> word, n))) < 0)
            p -> left_son = big_tree(p->left_son, vet, n);
        else if (cond > 0)
            p -> right_son = big_tree(p->right_son, vet, n);
    }
    return p;
}


#define BUFSIZE 100
char buf[BUFSIZE]; // буфер для ungetch
int bufp = 0; // след. свободная позиция в буфере
int getch(void) // взять (возможно возращенный) символ 
{   
    return (bufp > 0) ? buf[--bufp] : getchar();
}

void ungetch(int c) // вернуть символ на ввод. Чтобы избежать потери какого-либо символа и непредвиденных ошибок.
{
    if (bufp >= BUFSIZE)
        printf("ungetch: a lot of symbols\n");
    else
        buf[bufp++] = c;
}


/* getword: принимает следующее слово или символ из ввода */
int getword (char *word, int lim)
{   
    char c;
    char *w = word;
    while (isspace(c = getch()));
    if (c != EOF)
        *w++ = c;
    if (!isalpha(c)) {
        *w = '\0';
        return c;
    }
    for ( ; --lim > 0; w++)
        if (!isalnum(*w = getch())) {
            ungetch(*w);
            break;
        }
    *w = '\0';
    return word[0];
}

void treeprint_(struct tnode *a);
// Печать дерева(из деревьев) отсортированного по алфавиту 
void bigtreeprint(struct tree_of_trees *p){
    if (p != NULL){
        bigtreeprint(p -> left_son);
        treeprint_(p -> bin_tree);
        bigtreeprint(p -> right_son);
    }   
}

/* treeprint: упорядоченная печать дерева р */
void treeprint_(struct tnode *p)
{  
    if (p != NULL) {
        treeprint_(p->left);
        printf("%s\n", p->word);
        treeprint_(p->right);
    }
}

void free_tree(struct tnode *p) {
    if (p != NULL) {
        free_tree(p->left);
        free_tree(p->right);
        free(p->word);
        free(p);
    }
}

void free_big_tree(struct tree_of_trees *p) {
    if (p != NULL) {
        free_big_tree(p->left_son);
        free_big_tree(p->right_son);
        free_tree(p->bin_tree);
        free(p);
    }
}

int main(int argc, char *argv[])
{   
    int n = 6;
    while (--argc > 0) n = atoi(*++argv);
    struct tnode *root_internal;
    struct tree_of_trees *root_main;
    char word[100];
    root_main = NULL;
    root_internal = NULL;
    while (getword (word, 100) != EOF){
        if ((isalpha(word[0]) || word[0] == '_') && strlen(word) > n){
            root_main = big_tree(root_main, root_internal, n);
            root_internal = addtree(root_internal, word);
        }
    }
    bigtreeprint(root_main);
    free_big_tree(root_main);


    return 0;
}
c
Martin Hope
duad
Asked: 2024-11-30 15:35:01 +0800 CST
  • 6

这里我有代码

#include <stdio.h>

void what_in_variable1(void);
void what_in_variable2(void);
void what_in_variable3(void);

int main(void)
{
    what_in_variable1();
    what_in_variable2();
    what_in_variable3();
    return 0;
}

void what_in_variable1(void)
{
    int a;
    int b;
    int c;

    printf("a znachenie %d\n", a);
    printf("b znachenie %d\n", b);
    printf("c znachenie %d\n", c);
}

void what_in_variable2(void)
{
    int d;
    int e;
    int f;

    printf("d znachenie %d\n", d);
    printf("e znachenie %d\n", e);
    printf("f znachenie %d\n", f);
}

void what_in_variable3(void)
{
    int q;
    int o;
    int p;

    printf("q znachenie %d\n", q);
    printf("o znachenie %d\n", o);
    printf("p znachenie %d\n", p);
}

代码返回消息

a znachenie 0
b znachenie -134327328
c znachenie 32767
d znachenie 0
e znachenie -134327328
f znachenie 32767
q znachenie 0
o znachenie -134327328
p znachenie 32767

显然，这不是分配为变量之前内存中的数据，否则所有数字都会不同。出于同样的原因，这些不能是分配给变量的存储单元的地址。在这种情况下，函数中声明的最后一个变量始终等于32767，在其之前声明的变量始终等于-134327328，其前面的变量始终等于0。也就是说，如果他只是宣布的话a，那就b已经a是-134327328并且b本来就是32767。

或者代码是否经过编译，以便在人工赋值之前总是为变量分配一些默认值，具体取决于变量声明的顺序？

如果是这样，是否有可能以某种方式编写一个代码，在人们赋值之前不会为变量分配默认值，但能够看到最初存在的内容？也许另一个程序之前曾使用过这个存储单元，并在那里留下了一些有趣的数据——cookies、密码等。

c
Martin Hope
justSMTH
Asked: 2024-11-08 00:58:03 +0800 CST
  • 5

程序忽略 for 循环体。迭代通过，但调试器不进入主体。 VS22 构建调试。

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

typedef struct List {
    int data;
    struct List* Next;
} List;

void Add(List* ls, int data) {
    List* node = ls;
    ls = malloc(sizeof(List));
    ls->data = data;
    ls->Next = node;
}

int main() {
    List* ls = malloc(sizeof(List));
    ls->Next = NULL;
    ls->data = NULL;
    if (ls->Next == NULL) {
        ls->data = 2;
    }
    int i = 0;
    while (1) {
        char c = getchar();
        char num[16];
        if (isspace(c)) {
            if (num[0] != '\0') {
                Add(ls, atoi(num));
                for (int j = 0; j <= i; j++) { 
                    num[j] == '\0'; \\Полностью игнорируется
                }
                i=0;
            }
            continue;
        }
        else if (c == '.') {
            if (num[0] != '\0') {
                Add(ls, atoi(num));
                i++;
                for (; i <= 0; i--) {
                    num[i] == '\0';
                }
            }
            break;
        }
        else if (isdigit(c)) {
            num[i++] = c;
        }
        else {
            printf("Error");
            return 1;
        }
    }
    while (ls->Next != NULL) {
        printf("%d", ls->data);
    }
    return 0;
}
c