c - 当我在构建中添加 lib 链接时出现段错误-6ren

c - 当我在构建中添加 lib 链接时出现段错误

转载作者：太空宇宙更新时间：2023-11-04 11:19:13

我有一个成功构建的程序，但是当我运行该程序时出现段错误。

在这个程序的构建中，我链接到许多库:

-llib1 -llib2 -llib3

段错误与源代码无关，但与库加载 lib2 之一有关。

我试过一个 hello world 程序

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

int main()
{
    printf("hello world! \n");
}

当我使用 -llib1 -llib2 -llib3 构建时出现段错误

但是当我使用 -llib1 -llib3 构建时我没有遇到段错误

一般(没有细节)这个段错误的可能原因是什么？

编辑

lib2 在其头文件之一中包含以下行

#    ifdef __GNUC__
__attribute__ ((__format__ (__printf__, 3, 4)))
#    endif /* __GNUC__ */

上面的代码会导致段错误吗？

来自开源 libminixml

minixml.h

extern int      mxmlSetTextf(mxml_node_t *node, int whitespace,
                         const char *format, ...)
#    ifdef __GNUC__
__attribute__ ((__format__ (__printf__, 3, 4)))
#    endif /* __GNUC__ */
;
extern int      mxmlSetUserData(mxml_node_t *node, void *data);

整个minixml.h文件:

#ifndef _mxml_h_
#  define _mxml_h_

/*
 * Include necessary headers...
 */

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


/*
 * Constants...
 */

#  define MXML_TAB      8   /* Tabs every N columns */

#  define MXML_NO_CALLBACK  0   /* Don't use a type callback */
#  define MXML_INTEGER_CALLBACK mxml_integer_cb
                    /* Treat all data as integers */
#  define MXML_OPAQUE_CALLBACK  mxml_opaque_cb
                    /* Treat all data as opaque */
#  define MXML_REAL_CALLBACK    mxml_real_cb
                    /* Treat all data as real numbers */
#  define MXML_TEXT_CALLBACK    0   /* Treat all data as text */
#  define MXML_IGNORE_CALLBACK  mxml_ignore_cb
                    /* Ignore all non-element content */

#  define MXML_NO_PARENT    0   /* No parent for the node */

#  define MXML_DESCEND      1   /* Descend when finding/walking */
#  define MXML_NO_DESCEND   0   /* Don't descend when finding/walking */
#  define MXML_DESCEND_FIRST    -1  /* Descend for first find */

#  define MXML_WS_BEFORE_OPEN   0   /* Callback for before open tag */
#  define MXML_WS_AFTER_OPEN    1   /* Callback for after open tag */
#  define MXML_WS_BEFORE_CLOSE  2   /* Callback for before close tag */
#  define MXML_WS_AFTER_CLOSE   3   /* Callback for after close tag */

#  define MXML_ADD_BEFORE   0   /* Add node before specified node */
#  define MXML_ADD_AFTER    1   /* Add node after specified node */
#  define MXML_ADD_TO_PARENT    NULL    /* Add node relative to parent */


/*
 * Data types...
 */

typedef enum mxml_sax_event_e       /**** SAX event type. ****/
{
  MXML_SAX_CDATA,           /* CDATA node */
  MXML_SAX_COMMENT,         /* Comment node */
  MXML_SAX_DATA,            /* Data node */
  MXML_SAX_DIRECTIVE,           /* Processing directive node */
  MXML_SAX_ELEMENT_CLOSE,       /* Element closed */
  MXML_SAX_ELEMENT_OPEN         /* Element opened */
} mxml_sax_event_t;

typedef enum mxml_type_e        /**** The XML node type. ****/
{
  MXML_IGNORE = -1,         /* Ignore/throw away node @since Mini-XML 2.3@ */
  MXML_ELEMENT,             /* XML element with attributes */
  MXML_INTEGER,             /* Integer value */
  MXML_OPAQUE,              /* Opaque string */
  MXML_REAL,                /* Real value */
  MXML_TEXT,                /* Text fragment */
  MXML_CUSTOM               /* Custom data @since Mini-XML 2.1@ */
} mxml_type_t;

typedef void (*mxml_custom_destroy_cb_t)(void *);
                    /**** Custom data destructor ****/

typedef void (*mxml_error_cb_t)(const char *);  
                    /**** Error callback function ****/

typedef struct mxml_attr_s      /**** An XML element attribute value. @private@ ****/
{
  char          *name;      /* Attribute name */
  char          *value;     /* Attribute value */
} mxml_attr_t;

typedef struct mxml_element_s       /**** An XML element value. @private@ ****/
{
  char          *name;      /* Name of element */
  int           num_attrs;  /* Number of attributes */
  mxml_attr_t       *attrs;     /* Attributes */
} mxml_element_t;

typedef struct mxml_text_s      /**** An XML text value. @private@ ****/
{
  int           whitespace; /* Leading whitespace? */
  char          *string;    /* Fragment string */
} mxml_text_t;

typedef struct mxml_custom_s        /**** An XML custom value. @private@ ****/
{
  void          *data;      /* Pointer to (allocated) custom data */
  mxml_custom_destroy_cb_t destroy; /* Pointer to destructor function */
} mxml_custom_t;

typedef union mxml_value_u      /**** An XML node value. @private@ ****/
{
  mxml_element_t    element;    /* Element */
  int           integer;    /* Integer number */
  char          *opaque;    /* Opaque string */
  double        real;       /* Real number */
  mxml_text_t       text;       /* Text fragment */
  mxml_custom_t     custom;     /* Custom data @since Mini-XML 2.1@ */
} mxml_value_t;

struct mxml_node_s          /**** An XML node. @private@ ****/
{
  mxml_type_t       type;       /* Node type */
  struct mxml_node_s    *next;      /* Next node under same parent */
  struct mxml_node_s    *prev;      /* Previous node under same parent */
  struct mxml_node_s    *parent;    /* Parent node */
  struct mxml_node_s    *child;     /* First child node */
  struct mxml_node_s    *last_child;    /* Last child node */
  mxml_value_t      value;      /* Node value */
  int           ref_count;  /* Use count */
  void          *user_data; /* User data */
};

typedef struct mxml_node_s mxml_node_t; /**** An XML node. ****/

struct mxml_index_s          /**** An XML node index. @private@ ****/
{
  char          *attr;      /* Attribute used for indexing or NULL */
  int           num_nodes;  /* Number of nodes in index */
  int           alloc_nodes;    /* Allocated nodes in index */
  int           cur_node;   /* Current node */
  mxml_node_t       **nodes;    /* Node array */
};

typedef struct mxml_index_s mxml_index_t;
                    /**** An XML node index. ****/

typedef int (*mxml_custom_load_cb_t)(mxml_node_t *, const char *);
                    /**** Custom data load callback function ****/

typedef char *(*mxml_custom_save_cb_t)(mxml_node_t *);  
                    /**** Custom data save callback function ****/

typedef int (*mxml_entity_cb_t)(const char *);
                    /**** Entity callback function */

typedef mxml_type_t (*mxml_load_cb_t)(mxml_node_t *);
                    /**** Load callback function ****/

typedef const char *(*mxml_save_cb_t)(mxml_node_t *, int);
                    /**** Save callback function ****/

typedef void (*mxml_sax_cb_t)(mxml_node_t *, mxml_sax_event_t, void *);  
                    /**** SAX callback function ****/


/*
 * C++ support...
 */

#  ifdef __cplusplus
extern "C" {
#  endif /* __cplusplus */

/*
 * Prototypes...
 */

extern void     mxmlAdd(mxml_node_t *parent, int where,
                    mxml_node_t *child, mxml_node_t *node);
extern void     mxmlDelete(mxml_node_t *node);
extern void     mxmlElementDeleteAttr(mxml_node_t *node,
                                  const char *name);
extern const char   *mxmlElementGetAttrValue(mxml_node_t *node, const char *name);
extern const char   *mxmlElementGetAttrName(mxml_node_t *node, const char *value);
extern void     mxmlElementSetAttr(mxml_node_t *node, const char *name,
                               const char *value);
extern void     mxmlElementSetAttrf(mxml_node_t *node, const char *name,
                                const char *format, ...)
#    ifdef __GNUC_ttt__
__attribute__ ((__format__ (__printf__, 3, 4)))
#    endif /* __GNUC__ */
;
extern int      mxmlEntityAddCallback(mxml_entity_cb_t cb);
extern const char   *mxmlEntityGetName(int val);
extern int      mxmlEntityGetValue(const char *name);
extern void     mxmlEntityRemoveCallback(mxml_entity_cb_t cb);
extern mxml_node_t  *mxmlFindElement(mxml_node_t *node, mxml_node_t *top,
                     const char *name, const char *attr,
                     const char *value, int descend);
extern mxml_node_t  *mxmlFindElementText(mxml_node_t *node, mxml_node_t *top,
                         const char  *text, int descend);
extern mxml_node_t  *mxmlFindPath(mxml_node_t *node, const char *path);
extern const char   *mxmlGetCDATA(mxml_node_t *node);
extern const void   *mxmlGetCustom(mxml_node_t *node);
extern const char   *mxmlGetElement(mxml_node_t *node);
extern mxml_node_t  *mxmlGetFirstChild(mxml_node_t *node);
extern int      mxmlGetInteger(mxml_node_t *node);
extern mxml_node_t  *mxmlGetLastChild(mxml_node_t *node);
extern mxml_node_t  *mxmlGetNextSibling(mxml_node_t *node);
extern const char   *mxmlGetOpaque(mxml_node_t *node);
extern mxml_node_t  *mxmlGetParent(mxml_node_t *node);
extern mxml_node_t  *mxmlGetPrevSibling(mxml_node_t *node);
extern double       mxmlGetReal(mxml_node_t *node);
extern int      mxmlGetRefCount(mxml_node_t *node);
extern const char   *mxmlGetText(mxml_node_t *node, int *whitespace);
extern mxml_type_t  mxmlGetType(mxml_node_t *node);
extern void     *mxmlGetUserData(mxml_node_t *node);
extern void     mxmlIndexDelete(mxml_index_t *ind);
extern mxml_node_t  *mxmlIndexEnum(mxml_index_t *ind);
extern mxml_node_t  *mxmlIndexFind(mxml_index_t *ind,
                           const char *element,
                           const char *value);
extern int      mxmlIndexGetCount(mxml_index_t *ind);
extern mxml_index_t *mxmlIndexNew(mxml_node_t *node, const char *element,
                          const char *attr);
extern mxml_node_t  *mxmlIndexReset(mxml_index_t *ind);
extern mxml_node_t  *mxmlLoadFd(mxml_node_t *top, int fd,
                        mxml_type_t (*cb)(mxml_node_t *));
extern mxml_node_t  *mxmlLoadFile(mxml_node_t *top, FILE *fp,
                          mxml_type_t (*cb)(mxml_node_t *));
extern mxml_node_t  *mxmlLoadString(mxml_node_t *top, const char *s,
                            mxml_type_t (*cb)(mxml_node_t *));
extern mxml_node_t  *mxmlNewCDATA(mxml_node_t *parent, const char *string);
extern mxml_node_t  *mxmlNewCustom(mxml_node_t *parent, void *data,
                           mxml_custom_destroy_cb_t destroy);
extern mxml_node_t  *mxmlNewElement(mxml_node_t *parent, const char *name);
extern mxml_node_t  *mxmlNewInteger(mxml_node_t *parent, int integer);
extern mxml_node_t  *mxmlNewOpaque(mxml_node_t *parent, const char *opaque);
extern mxml_node_t  *mxmlNewReal(mxml_node_t *parent, double real);
extern mxml_node_t  *mxmlNewText(mxml_node_t *parent, int whitespace,
                         const char *string);
extern mxml_node_t  *mxmlNewTextf(mxml_node_t *parent, int whitespace,
                          const char *format, ...)
#    ifdef __GNUC_ttt__
__attribute__ ((__format__ (__printf__, 3, 4)))
#    endif /* __GNUC__ */
;
extern mxml_node_t  *mxmlNewXML(const char *version);
extern int      mxmlRelease(mxml_node_t *node);
extern void     mxmlRemove(mxml_node_t *node);
extern int      mxmlRetain(mxml_node_t *node);
extern char     *mxmlSaveAllocString(mxml_node_t *node,
                             mxml_save_cb_t cb);
extern int      mxmlSaveFd(mxml_node_t *node, int fd,
                       mxml_save_cb_t cb);
extern int      mxmlSaveFile(mxml_node_t *node, FILE *fp,
                         mxml_save_cb_t cb);
extern int      mxmlSaveString(mxml_node_t *node, char *buffer,
                           int bufsize, mxml_save_cb_t cb);
extern mxml_node_t  *mxmlSAXLoadFd(mxml_node_t *top, int fd,
                           mxml_type_t (*cb)(mxml_node_t *),
                           mxml_sax_cb_t sax, void *sax_data);
extern mxml_node_t  *mxmlSAXLoadFile(mxml_node_t *top, FILE *fp,
                             mxml_type_t (*cb)(mxml_node_t *),
                             mxml_sax_cb_t sax, void *sax_data);
extern mxml_node_t  *mxmlSAXLoadString(mxml_node_t *top, const char *s,
                               mxml_type_t (*cb)(mxml_node_t *),
                               mxml_sax_cb_t sax, void *sax_data);
extern int      mxmlSetCDATA(mxml_node_t *node, const char *data);
extern int      mxmlSetCustom(mxml_node_t *node, void *data,
                          mxml_custom_destroy_cb_t destroy);
extern void     mxmlSetCustomHandlers(mxml_custom_load_cb_t load,
                                  mxml_custom_save_cb_t save);
extern int      mxmlSetElement(mxml_node_t *node, const char *name);
extern void     mxmlSetErrorCallback(mxml_error_cb_t cb);
extern int      mxmlSetInteger(mxml_node_t *node, int integer);
extern int      mxmlSetOpaque(mxml_node_t *node, const char *opaque);
extern int      mxmlSetReal(mxml_node_t *node, double real);
extern int      mxmlSetText(mxml_node_t *node, int whitespace,
                        const char *string);
extern int      mxmlSetTextf(mxml_node_t *node, int whitespace,
                         const char *format, ...)
#    ifdef __GNUC_ttt__
__attribute__ ((__format__ (__printf__, 3, 4)))
#    endif /* __GNUC__ */
;
extern int      mxmlSetUserData(mxml_node_t *node, void *data);
extern void     mxmlSetWrapMargin(int column);
extern mxml_node_t  *mxmlWalkNext(mxml_node_t *node, mxml_node_t *top,
                          int descend);
extern mxml_node_t  *mxmlWalkPrev(mxml_node_t *node, mxml_node_t *top,
                          int descend);


/*
 * Semi-private functions...
 */

extern void     mxml_error(const char *format, ...);
extern mxml_type_t  mxml_ignore_cb(mxml_node_t *node);
extern mxml_type_t  mxml_integer_cb(mxml_node_t *node);
extern mxml_type_t  mxml_opaque_cb(mxml_node_t *node);
extern mxml_type_t  mxml_real_cb(mxml_node_t *node);


/*
 * C++ support...
 */

#  ifdef __cplusplus
}
#  endif /* __cplusplus */
#endif /* !_mxml_h_ */

在minixml.h

中定义了3次

跟踪

 strace ./test
execve("./test", ["./test"], [/* 10 vars */]) = 0
old_mmap(NULL, 4096, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS|0x4000000, -1, 0) = 0x77885000
stat("/etc/ld.so.cache", 0x7fa6a5a0)    = -1 ENOENT (No such file or directory)
open("/lib/libmicroxml.so.1", O_RDONLY) = -1 ENOENT (No such file or directory)
open("/lib/libmicroxml.so.1", O_RDONLY) = -1 ENOENT (No such file or directory)
open("/usr/lib/libmicroxml.so.1", O_RDONLY) = 3
fstat(3, {st_mode=S_IFREG|0755, st_size=40128, ...}) = 0
old_mmap(NULL, 4096, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS|0x4000000, -1, 0) = 0x77884000
read(3, "\177ELF\1\2\1\0\0\0\0\0\0\0\0\0\0\3\0\10\0\0\0\1\0\0\34@\0\0\0004"..., 4096) = 4096
old_mmap(NULL, 106496, PROT_NONE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0) = 0x77856000
old_mmap(0x77856000, 37332, PROT_READ|PROT_EXEC, MAP_PRIVATE|MAP_FIXED, 3, 0) = 0x77856000
old_mmap(0x7786f000, 3264, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_FIXED, 3, 0x9000) = 0x7786f000
close(3)                                = 0
munmap(0x77884000, 4096)                = 0
open("/lib/libgcc_s.so.1", O_RDONLY)    = 3
fstat(3, {st_mode=S_IFREG|0644, st_size=78232, ...}) = 0
old_mmap(NULL, 4096, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS|0x4000000, -1, 0) = 0x77884000
read(3, "\177ELF\1\2\1\0\0\0\0\0\0\0\0\0\0\3\0\10\0\0\0\1\0\0006\320\0\0\0004"..., 4096) = 4096
old_mmap(NULL, 147456, PROT_NONE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0) = 0x77832000
old_mmap(0x77832000, 76928, PROT_READ|PROT_EXEC, MAP_PRIVATE|MAP_FIXED, 3, 0) = 0x77832000
old_mmap(0x77855000, 408, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_FIXED, 3, 0x13000) = 0x77855000
close(3)                                = 0
munmap(0x77884000, 4096)                = 0
open("/lib/libc.so.0", O_RDONLY)        = 3
fstat(3, {st_mode=S_IFREG|0755, st_size=413076, ...}) = 0
old_mmap(NULL, 4096, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS|0x4000000, -1, 0) = 0x77884000
read(3, "\177ELF\1\2\1\0\0\0\0\0\0\0\0\0\0\3\0\10\0\0\0\1\0\0\253`\0\0\0004"..., 4096) = 4096
old_mmap(NULL, 503808, PROT_NONE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0) = 0x777b7000
old_mmap(0x777b7000, 405592, PROT_READ|PROT_EXEC, MAP_PRIVATE|MAP_FIXED, 3, 0) = 0x777b7000
old_mmap(0x7782a000, 7572, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_FIXED, 3, 0x63000) = 0x7782a000
old_mmap(0x7782c000, 21036, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_FIXED|MAP_ANONYMOUS, -1, 0) = 0x7782c000
close(3)                                = 0
munmap(0x77884000, 4096)                = 0
open("/usr/lib/libgcc_s.so.1", O_RDONLY) = 3
fstat(3, {st_mode=S_IFREG|0755, st_size=169712, ...}) = 0
old_mmap(NULL, 4096, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS|0x4000000, -1, 0) = 0x77884000
read(3, "\177ELF\1\2\1\0\0\0\0\0\0\0\0\0\0\3\0\10\0\0\0\1\0\0\307\220\0\0\0004"..., 4096) = 4096
old_mmap(NULL, 237568, PROT_NONE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0) = 0x7777d000
old_mmap(0x7777d000, 169036, PROT_READ|PROT_EXEC, MAP_PRIVATE|MAP_FIXED, 3, 0) = 0x7777d000
old_mmap(0x777b6000, 1776, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_FIXED, 3, 0x29000) = 0x777b6000
close(3)                                = 0
munmap(0x77884000, 4096)                = 0
open("/usr/lib/libc.so.0", O_RDONLY)    = 3
fstat(3, {st_mode=S_IFREG|0755, st_size=425968, ...}) = 0
old_mmap(NULL, 4096, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS|0x4000000, -1, 0) = 0x77884000
read(3, "\177ELF\1\2\1\0\0\0\0\0\0\0\0\0\0\3\0\10\0\0\0\1\0\0\267`\0\0\0004"..., 4096) = 4096
old_mmap(NULL, 516096, PROT_NONE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0) = 0x776ff000
old_mmap(0x776ff000, 418924, PROT_READ|PROT_EXEC, MAP_PRIVATE|MAP_FIXED, 3, 0) = 0x776ff000
old_mmap(0x77775000, 8176, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_FIXED, 3, 0x66000) = 0x77775000
old_mmap(0x77777000, 21784, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_FIXED|MAP_ANONYMOUS, -1, 0) = 0x77777000
close(3)                                = 0
munmap(0x77884000, 4096)                = 0
open("/lib/libc.so.0", O_RDONLY)        = 3
fstat(3, {st_mode=S_IFREG|0755, st_size=413076, ...}) = 0
close(3)                                = 0
stat("/lib/ld-uClibc.so.0", {st_mode=S_IFREG|0755, st_size=28976, ...}) = 0
open("/lib/libc.so.0", O_RDONLY)        = 3
fstat(3, {st_mode=S_IFREG|0755, st_size=413076, ...}) = 0
close(3)                                = 0
old_mmap(NULL, 4096, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS|0x4000000, -1, 0) = 0x77884000
set_thread_area(0x7788b440)             = 0
mprotect(0x7782a000, 4096, PROT_READ)   = 0
mprotect(0x77775000, 4096, PROT_READ)   = 0
mprotect(0x77886000, 4096, PROT_READ)   = 0
--- SIGSEGV (Segmentation fault) @ 0 (0) ---
+++ killed by SIGSEGV +++
Segmentation fault

最佳答案

在共享库中，如果使用__attribute__((constructor))定义函数，则在加载共享库时自动执行。

由于您没有从该共享库中调用任何函数，因此该库(使用构造函数属性定义的代码)的初始化代码中一定发生了崩溃。这很可能是库中的错误或未满足该库的某些假设。很可能，它需要存在另一个共享库，而该共享库不存在于您的系统中。

关于c - 当我在构建中添加 lib 链接时出现段错误，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/19290142/

文章推荐： c - 在 POSIX semop() 参数中，sem_flg = 0 的含义是什么

文章推荐： php - 如何从 PHP 使用 bash 脚本？

文章推荐： html - 使链接中的文本完全适合图像下方

文章推荐： java - 有效的多边形碰撞检测

javascript - 我需要将文本放在一个中，它位于一个 Div 中，该 Div 位于另一个 Div 中，该 Div 位于另一个 Div 中
我需要将文本放在中在一个 Div 中，在另一个 Div 中，在另一个 Div 中。所以这是它的样子: #document Change PIN
html - 两个背景图像。一个在 HTML 中，一个在 BODY 中。在 Firefox 中，主体图像未呈现
奇怪的事情发生了。我有一个基本的 html 代码。 html，头部， body 。(因为我收到了一些反对票，这里是完整的代码) 这是我的CSS: html { backgroun
ios - 将图像从 asset.xcassets 加载到 imageArray 中，并将其动态加载到 UIImageView 中，该 UIImageView 存在于 UICollectionView 中 - swift
我正在尝试将 Assets 中的一组图像加载到 UICollectionview 中存在的 ImageView 中，但每当我运行应用程序时它都会显示错误。而且也没有显示图像。我在ViewDidLoa
linux - 在 BASH 中，我需要根据 perl 脚本的输出更改一些环境变量。在 tcsh 中，我可以使用别名 eval 组合。不能在 bash 中
我需要根据带参数的 perl 脚本的输出更改一些环境变量。在 tcsh 中，我可以使用别名命令来评估 perl 脚本的输出。 tcsh: alias setsdk 'eval `/localhome/
asp.net - Windows 身份验证适用于 IIS，但不适用于 Kestrel/Microsoft.AspNetCore.Authentication.Negotiate(不在 Chrome 中，有时在 Edge 中，始终在 IE 中)？
我使用 Windows 身份验证创建了一个新的 Blazor(服务器端)应用程序，并使用 IIS Express 运行它。它将显示一条消息“Hello Domain\User!”来自右上方的以下 Ra
java - java 中 Kotlin 中的等价物是什么？
这是我的方法 void login(Event event);我想知道 Kotlin 中应该如何最佳答案在 Kotlin 中通配符运算符是 * 。它指示编译器它是未知的，但一旦知道，就不会有其他类
express - 在 Jade 中，为什么有时我可以按原样使用变量而有时必须将它们包含在#{......} 中？
看下面的代码 for story in book if story.title.length < 140 - var story
c - C 中 strstr() 中 for 循环的错误使用
我正在尝试用 C 语言学习字符串处理。我写了一个程序，它存储了一些音乐轨道，并帮助用户检查他/她想到的歌曲是否存在于存储的轨道中。这是通过要求用户输入一串字符来完成的。然后程序使用 strstr()
c - * 在 sscanf 中，* 在 [] 中
我正在学习 sscanf 并遇到如下格式字符串: sscanf("%[^:]:%[^*=]%*[*=]%n",a,b,&c); 我理解 %[^:] 部分意味着扫描直到遇到 ':' 并将其分配给 a。:
python - 在 Python (2.7.3) 中，如果 str(x) 中的任何字符在 str(y) 中(或 str(y) 在 str(x) 中)，我如何编写一个函数来回答？
def char_check(x,y): if (str(x) in y or x.find(y) > -1) or (str(y) in x or y.find(x) > -1):
ansible - 在 Ansible 中，如何将一行移动到一个 block 中？
我有一种情况，我想将文本文件中的现有行包含到一个新 block 中。 line 1 line 2 line in block line 3 line 4 应该变成 line 1 line 2 line
Django 调试工具栏显示在根 URL 中，但不显示在应用程序 URL 中
我有一个新项目，我正在尝试设置 Django 调试工具栏。首先，我尝试了快速设置，它只涉及将 'debug_toolbar' 添加到我的已安装应用程序列表中。有了这个，当我转到我的根 URL 时，调试
r - 在 R 中，Matlab 中 @ 函数句柄的等价物是什么？
在 Matlab 中，如果我有一个函数 f，例如签名是 f(a,b,c)，我可以创建一个只有一个变量 b 的函数，它将使用固定的 a=a1 和 c=c1 调用 f: g = @(b) f(a1, b,
swiftui - SwiftUI 中 ScrollView 中 VStack 元素中的神秘间距或填充
我不明白为什么 ForEach 中的元素之间有多余的垂直间距在 VStack 里面在 ScrollView 里面使用 GeometryReader 时渲染自定义水平分隔线。 Scrol
cookies - 什么应该存储在 session 中，什么应该存储在 cookie 中？
我想知道，是否有关于何时使用 session 和 cookie 的指南或最佳实践？什么应该和什么不应该存储在其中？谢谢! 最佳答案这些文档很好地了解了 session cookie 的安全问题以及
python - Python 中 matplotlib 中 3d 直方图的奇怪行为
我在 scipy/numpy 中有一个 Nx3 矩阵，我想用它制作一个 3 维条形图，其中 X 轴和 Y 轴由矩阵的第一列和第二列的值、高度确定每个条形的是矩阵中的第三列，条形的数量由 N 确定。
c - c 中 sem_init(...) 中 value 参数的不同用法
假设我用两种不同的方式初始化信号量 sem_init(&randomsem,0,1) sem_init(&randomsem,0,0) 现在， sem_wait(&randomsem) 在这两种情况下
c - 实际值存储在 pstr 中，但是该值如何存储在数组 "WORD"中
我怀疑该值如何存储在“WORD”中，因为 PStr 包含实际输出。？既然Pstr中存储的是小写到大写的字母，那么在printf中如何将其给出为“WORD”。有人可以吗？解释一下？ #include
javascript - 数组索引选择像在 numpy 中，但在 javascript 中
我有一个 3x3 数组: var my_array = [[0,1,2], [3,4,5], [6,7,8]]; 并想获得它的第一个 2
javascript - 在 Javascript 中，如何检测浏览器窗口何时在 View 中？
我意识到您可以使用如下方式轻松检查焦点: var hasFocus = true; $(window).blur(function(){ hasFocus = false; }); $(win

太空宇宙

个人简介

我是一名优秀的程序员,十分优秀！

作者热门文章

滴滴打车优惠券免费领取

全站热门文章

首页

博学

6Ren·AI

商城

c - 当我在构建中添加 lib 链接时出现段错误