什么是bash中一次采购的好方法.
bash是否存储已经获取的文件的路径,或者我是否需要使所有source/ .调用通过将存储这些路径的包装器？
是否有一个标准可用的机制可以找到源参数解析的内容？which除非文件是可执行的,否则似乎不起作用.
我有一个函数指针,其函数被声明为期望char *参数.对于它,我想保存一个指向声明为接受char const*参数的函数的指针.
我想我可以使用包装器或演员.强制转换似乎更直接,但我可以合法地调用这样的函数指针的结果吗？
示例代码如下:
static int write_a(char * X){
return 0;
}
static int write_b(char const* X){
return 0;
}
static int wrapped_write_b(char * X){
return write_b(X);
}
typedef int (*write_fn)(char * );
write_fn a = write_a;
write_fn b = wrapped_write_b;
write_fn b1 = (write_fn)write_b; //is b1 legally callable?
我正在尝试使用gcc和clang来查看它们是否可以优化
#define SCOPE static
SCOPE const struct wrap_ { const int x; } ptr = { 42 /*==0x2a*/ };
SCOPE struct wrap { const struct wrap_ *ptr; } const w = { &ptr };
int ret_global(void) { return w.ptr->x; }
返回一个中间常量.
事实证明他们可以:
0000000000000010 <ret_global>:
10: b8 2a 00 00 00 mov $0x2a,%eax
15: c3 retq
但令人惊讶的是,移除静态会产生相同的装配输出.这让我很好奇,因为如果全局不是static它应该是可插入的并且用中间体替换引用应该防止全局变量上的位置.
确实如此:
#!/bin/sh -eu
: ${CC:=gcc}
cat > lib.c <<EOF
int ret_42(void) { return 42; }
#define SCOPE
SCOPE const struct wrap_ { …我想调试一个在标识符扩展中使用美元的程序。
拿
#include <stdio.h>
int main()
{
int $a = 42, b= 43;
printf("%d %d\n", $a, b);
}
举个简单的例子。如果我在 gdb 下运行它，我可以b使用进行检查p b，但因为p $a我得到void. 我只能用info locals.
有没有办法在 gdb 中引用包含 $ 的标识符？
有没有办法干这个(没有宏)？
void clear_tp_vec(vector<const Tk*>& tps){
for(auto it=tps.begin();it!=tps.end();++it ){
const ValT* vp=dynamic_cast<const ValT*>(*it);
if(vp!=NULL)
delete vp;
}
tps.clear();
};
void clear_tp_vec(vector<Tk*>& tps){
for(auto it=tps.begin();it!=tps.end();++it ){
ValT* vp=dynamic_cast<ValT*>(*it);
if(vp!=NULL)
delete vp;
}
tps.clear();
};
第二个重载唯一不同的是const限定符(缺少它).注释掉任一版本都会破坏我的代码.
我想获得无参数:map调用的输出,以便我可以使用vim的搜索功能来查找映射.
我找到了:redir,它将ex命令的输出重定向到变量,寄存器或文件中,但它似乎不适用于map,它必须以某种不同的方式输出映射,例如:echo 'hello world'.
是否可以编写一个解析字符串文字参数的gcc宏？我知道相反的可能性#.可以逆转吗？
例如,__func__ 以字符串文字的形式计算当前函数的名称.我可以删除它周围的双引号吗？
有静态库,然后有共享库.如果需要,是不是可以只拥有共享的并静态链接它们？
编译一次,-fPIC一次没有看起来像是浪费.我不太了解汇编,但是不应该可以将可重新分配的代码转换为比重新编译所有内容更快的数量级的静态代码吗？
假设我有一个具有两个成员a且b具有相同类型的联合u (例如,int).
union u{
int a,b;
char c;
};
如果我写入a,通过值传递给函数,并且函数读取b,期望获得a值,是否会有任何问题,考虑a并b具有相同的类型？成员读取是否需要镜像成员写入？
如果复合文字出现在函数体外,则该对象具有静态存储持续时间; 否则,它具有与封闭块相关的自动存储持续时间.
我是否正确将"封闭块"解释为"最里面的封闭块"？(因为如果它不是最里面的那个,那是什么？) 为什么gcc和clang表现得好像文字的生命周期是它的封闭函数？
例:
long foo(long*);
void call_foo()
{
{foo(&(long){42});}
{foo(&(long){42});}
{foo(&(long){42});}
{foo(&(long){42});}
}
//for comparison
void call_foo2()
{
{long x=42;foo(&x);}
{long x=42;foo(&x);}
{long x=42;foo(&x);}
{long x=42;foo(&x);}
}
gcc/clang在-O3生成的代码:
call_foo:
sub rsp, 40
mov rdi, rsp
mov QWORD PTR [rsp], 42
call foo
lea rdi, [rsp+8]
mov QWORD PTR [rsp+8], 42
call foo
lea rdi, [rsp+16]
mov QWORD PTR [rsp+16], 42
call foo
lea rdi, [rsp+24]
mov QWORD PTR [rsp+24], 42
call foo
add rsp, 40
ret …