tailcall编译选项关闭

㈠ 关于linux gcc编译器关闭gs验证机制“ -fno-stack-protector ”

内核和应用程序的编译是不一样的，编译应用的时候会调用一些你的编译器工具链里的libc库的，但是编译内核的时候是不能call这些lib的，所以不能按着编译应用的思想去编译内核。你这个选项根本对内核无用。

㈡ -Wno-deprecated-declarations编译选项什么意思

这个编译选项是用来关闭Xcode中关于废弃API的警告
比如 你代码中使用了某个已经被废弃的API 这是Xcode会出现一个警告
这时你就可以通过这个编译选项 关闭掉这个警告。

㈢ C++ int i[233];我直接这样写代表了什么意思

C++ int i[233];直接这样写代表了，定义了一个整形的数组，共有233个整形元素，数组的名字叫做i。

㈣ Dev-C++一直提示“源文件未编译”怎么解决

1、打开DEV-C++，点击菜单栏中的“工具”，点击“编译选项”这个选项，打开编译选项对话框。

5、最后，重启DEV-C++即可，问题完美解决，可以继续完美地使用调试功能啦。

㈤ gcc 编译优化做了哪些事求解答

用过gcc的都应该知道编译时候的-O选项吧。它就是负责编译优化。下面列出它的说明： -O -O1 Optimize. Optimizing compilation takes somewhat more time, and a lot more memory for a large function. With -O, the compiler tries to rece code size and execution time, without performing any optimizations that take a great deal of compilation time. -O turns on the following optimization flags: -fdefer-pop -fdelayed-branch -fguess-branch-probability -fcprop-registers -floop-optimize -fif-conversion -fif-conver- sion2 -ftree-ccp -ftree-dce -ftree-dominator-opts -ftree-dse -ftree-ter -ftree-lrs -ftree-sra -ftree-rename -ftree-fre -ftree-ch -funit-at-a-time -fmerge-constants -O also turns on -fomit-frame-pointer on machines where doing so does not interfere with debugging. -O doesn’t turn on -ftree-sra for the Ada compiler. This option must be explicitly speci- fied on the command line to be enabled for the Ada compiler. -O2 Optimize even more. GCC performs nearly all supported optimizations that do not involve a space-speed tradeoff. The compiler does not perform loop unrolling or function inlining when you specify -O2. As compared to -O, this option increases both compilation time and the performance of the generated code. -O2 turns on all optimization flags specified by -O. It also turns on the following opti- mization flags: -fthread-jumps -fcrossjumping -foptimize-sibling-calls -fcse-follow-jumps -fcse-skip-blocks -fgcse -fgcse-lm -fexpensive-optimizations -fstrength-rece -fre- run-cse-after-loop -frerun-loop-opt -fcaller-saves -fpeephole2 -fschele-insns -fsched- ule-insns2 -fsched-interblock -fsched-spec -fregmove -fstrict-aliasing -fdelete-null-pointer-checks -freorder-blocks -freorder-functions -falign-functions -falign-jumps -falign-loops -falign-labels -ftree-vrp -ftree-pre Please note the warning under -fgcse about invoking -O2 on programs that use computed gotos. -O3 Optimize yet more. -O3 turns on all optimizations specified by -O2 and also turns on the -finline-functions, -funswitch-loops and -fgcse-after-reload options. -O0 Do not optimize. This is the default. -Os Optimize for size. -Os enables all -O2 optimizations that do not typically increase code size. It also performs further optimizations designed to rece code size. -Os disables the following optimization flags: -falign-functions -falign-jumps -falign-loops -falign-labels -freorder-blocks -freorder-blocks-and-partition -fprefetch-loop-arrays -ftree-vect-loop-version If you use multiple -O options, with or without level numbers, the last such option is the one that is effective. Options of the form -fflag specify machine-independent flags. Most flags have both positive and negative forms; the negative form of -ffoo would be -fno-foo. In the table below, only one of the forms is listed---the one you typically will use. You can figure out the other form by either removing no- or adding it. The following options control specific optimizations. They are either activated by -O options or are related to ones that are. You can use the following flags in the rare cases when "fine-tuning" of optimizations to be performed is desired. -fno-default-inline Do not make member functions inline by default merely because they are defined inside the class scope (C++ only). Otherwise, when you specify -O, member functions defined inside class scope are compiled inline by default; i.e., you don’t need to add inline in front of the member function name. -fno-defer-pop Always pop the arguments to each function call as soon as that function returns. For machines which must pop arguments after a function call, the compiler normally lets argu- ments accumulate on the stack for several function calls and pops them all at once. Disabled at levels -O, -O2, -O3, -Os. -fforce-mem Force memory operands to be copied into registers before doing arithmetic on them. This proces better code by making all memory references potential common subexpressions. When they are not common subexpressions, instruction combination should eliminate the separate register-load. This option is now a nop and will be removed in 4.2. -fforce-addr Force memory address constants to be copied into registers before doing arithmetic on them. -fomit-frame-pointer Don’t keep the frame pointer in a register for functions that don’t need one. This avoids the instructions to save, set up and restore frame pointers; it also makes an extra regis- ter available in many functions. It also makes debugging impossible on some machines. On some machines, such as the VAX, this flag has no effect, because the standard calling sequence automatically handles the frame pointer and nothing is saved by pretending it doesn’t exist. The machine-description macro "FRAME_POINTER_REQUIRED" controls whether a target machine supports this flag. Enabled at levels -O, -O2, -O3, -Os. -foptimize-sibling-calls Optimize sibling and tail recursive calls. Enabled at levels -O2, -O3, -Os. -fno-inline Don’t pay attention to the "inline" keyword. Normally this option is used to keep the com- piler from expanding any functions inline. Note that if you are not optimizing, no func- tions can be expanded inline. -finline-functions Integrate all simple functions into their callers. The compiler heuristically decides which functions are simple enough to be worth integrating in this way. If all calls to a given function are integrated, and the function is declared "static", then the function is normally not output as assembler code in its own right. Enabled at level -O3. -finline-functions-called-once Consider all "static" functions called once for inlining into their caller even if they are not marked "inline". If a call to a given function is integrated, then the function is not output as assembler code in its own right. Enabled if -funit-at-a-time is enabled. -fearly-inlining Inline functions marked by "always_inline" and functions whose body seems smaller than the function call overhead early before doing -fprofile-generate instrumentation and real inlining pass. Doing so makes profiling significantly cheaper and usually inlining faster on programs having large chains of nested wrapper functions. Enabled by default. -finline-limit=n By default, GCC limits the size of functions that can be inlined. This flag allows the control of this limit for functions that are explicitly marked as inline (i.e., marked with the inline keyword or defined within the class definition in c++). n is the size of func- tions that can be inlined in number of pseudo instructions (not counting parameter han- dling). The default value of n is 600. Increasing this value can result in more inlined code at the cost of compilation time and memory consumption. Decreasing usually makes the compilation faster and less code will be inlined (which presumably means slower programs). This option is particularly useful for programs that use inlining heavily such as those based on recursive templates with C++. Inlining is actually controlled by a number of parameters, which may be specified indivi- ally by using --param name=value. The -finline-limit=n option sets some of these parame- ters as follows: max-inline-insns-single is set to I<n>/2. max-inline-insns-auto is set to I<n>/2. min-inline-insns is set to 130 or I<n>/4, whichever is smaller. max-inline-insns-rtl is set to I<n>. See below for a documentation of the indivial parameters controlling inlining. Note: pseudo instruction represents, in this particular context, an abstract measurement of function’s size. In no way does it represent a count of assembly instructions and as such its exact meaning might change from one release to an another. -fkeep-inline-functions In C, emit "static" functions that are declared "inline" into the object file, even if the function has been inlined into all of its callers. This switch does not affect functions using the "extern inline" extension in GNU C. In C++, emit any and all inline functions into the object file. -fkeep-static-consts Emit variables declared "static const" when optimization isn’t turned on, even if the vari- ables aren’t referenced. GCC enables this option by default. If you want to force the compiler to check if the variable was referenced, regardless of whether or not optimization is turned on, use the -fno-keep-static-consts option. -fmerge-constants Attempt to merge identical constants (string constants and floating point constants) across compilation units. This option is the default for optimized compilation if the assembler and linker support it. Use -fno-merge-constants to inhibit this behavior. Enabled at levels -O, -O2, -O3, -Os. -fmerge-all-constants Attempt to merge identical constants and identical variables. This option implies -fmerge-constants. In addition to -fmerge-constants this considers e.g. even constant initialized arrays or initialized constant variables with integral or floating point types. Languages like C or C++ require each non-automatic variable to have distinct location, so using this option will result in non-conforming behavior. -fmolo-sched Perform swing molo scheling immediately before the first scheling pass. This pass looks at innermost loops and reorders their instructions by overlapping different itera- tions. -fno-branch-count-reg Do not use "decrement and branch" instructions on a count register, but instead generate a sequence of instructions that decrement a register, compare it against zero, then branch based upon the result. This option is only meaningful on architectures that support such instructions, which include x86, PowerPC, IA-64 and S/390. The default is -fbranch-count-reg, enabled when -fstrength-rece is enabled. -fno-function-cse Do not put function addresses in registers; make each instruction that calls a constant function contain the function’s address explicitly. This option results in less efficient code, but some strange hacks that alter the assembler output may be confused by the optimizations performed when this option is not used. The default is -ffunction-cse -fno-zero-initialized-in-bss If the target supports a BSS section, GCC by default puts variables that are initialized to zero into BSS. This can save space in the resulting code. This option turns off this behavior because some programs explicitly rely on variables going to the data section. E.g., so that the resulting executable can find the beginning of that section and/or make assumptions based on that. The default is -fzero-initialized-in-bss. -fmudflap -fmudflapth -fmudflapir For front-ends that support it (C and C++), instrument all risky pointer/array dereferenc- ing operations, some standard library string/heap functions, and some other associated con- structs with range/validity tests. Moles so instrumented should be immune to buffer overflows, invalid heap use, and some other classes of C/C++ programming errors. The instrumentation relies on a separate runtime library (libmudflap), which will be linked into a program if -fmudflap is given at link time. Run-time behavior of the instrumented program is controlled by the MUDFLAP_OPTIONS environment variable. See "env MUD- FLAP_OPTIONS=-help a.out" for its options. Use -fmudflapth instead of -fmudflap to compile and to link if your program is multi-threaded. Use -fmudflapir, in addition to -fmudflap or -fmudflapth, if instrumenta- tion should ignore pointer reads. This proces less instrumentation (and therefore faster execution) and still provides some protection against outright memory corrupting writes, but allows erroneously read data to propagate within a program. -fstrength-rece Perform the optimizations of loop strength rection and elimination of iteration vari- ables. Enabled at levels -O2, -O3, -Os. -fthread-jumps Perform optimizations where we check to see if a jump branches to a location where another comparison subsumed by the first is found. If so, the first branch is redirected to either the destination of the second branch or a point immediately following it, depending on whether the condition is known to be true or false. Enabled at levels -O2, -O3, -Os. -fcse-follow-jumps In common subexpression elimination, scan through jump instructions when the target of the jump is not reached by any other path. For example, when CSE encounters an "if" statement with an "else" clause, CSE will follow the jump when the condition tested is false. Enabled at levels -O2, -O3, -Os. -fcse-skip-blocks This is similar to -fcse-follow-jumps, but causes CSE to follow jumps which conditionally skip over blocks. When CSE encounters a simple "if" statement with no else clause, -fcse-skip-blocks causes CSE to follow the jump around the body of the "if". Enabled at levels -O2, -O3, -Os. -frerun-cse-after-loop Re-run common subexpression elimination after loop optimizations has been performed. Enabled at levels -O2, -O3, -Os. -frerun-loop-opt Run the loop optimizer twice. Enabled at levels -O2, -O3, -Os. -fgcse Perform a global common subexpression elimination pass. This pass also performs global constant and propagation. Note: When compiling a program using computed gotos, a GCC extension, you may get better runtime performance if you disable the global common subexpression elimination pass by adding -fno-gcse to the command line. Enabled at levels -O2, -O3, -Os. -fgcse-lm When -fgcse-lm is enabled, global common subexpression elimination will attempt to move loads which are only killed by stores into themselves. This allows a loop containing a load/store sequence to be changed to a load outside the loop, and a /store within the loop. Enabled by default when gcse is enabled. -fgcse-sm When -fgcse-sm is enabled, a store motion pass is run after global common subexpression elimination. This pass will attempt to move stores out of loops. When used in conjunction with -fgcse-lm, loops containing a load/store sequence can be changed to a load before the loop and a store after the loop. Not enabled at any optimization level. -fgcse-las When -fgcse-las is enabled, the global common subexpression elimination pass eliminates rendant loads that come after stores to the same memory location (both partial and full rendancies). Not enabled at any optimization level. -fgcse-after-reload When -fgcse-after-reload is enabled, a rendant load elimination pass is performed after reload. The purpose of this pass is to cleanup rendant spilling. -floop-optimize Perform loop optimizations: move constant expressions out of loops, simplify exit test con- ditions and optionally do strength-rection as well. Enabled at levels -O, -O2, -O3, -Os. -floop-optimize2 Perform loop optimizations using the new loop optimizer. The optimizations (loop unrolling, peeling and unswitching, loop invariant motion) are enabled by separate flags. -funsafe-loop-optimizations If given, the loop optimizer will assume that loop indices do not overflow, and that the loops with nontrivial exit condition are not infinite. This enables a wider range of loop optimizations even if the loop optimizer itself cannot prove that these assumptions are valid. Using -Wunsafe-loop-optimizations, the compiler will warn you if it finds this kind of loop. -fcrossjumping Perform cross-jumping transformation. This transformation unifies equivalent code and save code size. The resulting code may or may not perform better than without cross-jumping. Enabled at levels -O2, -O3, -Os. -fif-conversion Attempt to transform conditional jumps into branch-less equivalents. This include use of conditional moves, min, max, set flags and abs instructions, and some tricks doable by standard arithmetics. The use of conditional execution on chips where it is available is controlled by "if-conversion2". Enabled at levels -O, -O2, -O3, -Os. -fif-conversion2 Use conditional execution (where available) to transform conditional jumps into branch-less equivalents. Enabled at levels -O, -O2, -O3, -Os. -fdelete-null-pointer-checks Use global dataflow analysis to identify and eliminate useless checks for null pointers. The compiler assumes that dereferencing a null pointer would have halted the program. If a pointer is checked after it has already been dereferenced, it cannot be null. In some environments, this assumption is not true, and programs can safely dereference null pointers. Use -fno-delete-null-pointer-checks to disable this optimization for programs which depend on that behavior. Enabled at levels -O2, -O3, -Os. -fexpensive-optimizations Perform a number of minor optimizations that are relatively expensive. Enabled at levels -O2, -O3, -Os. -foptimize-register-move -fregmove Attempt to reassign register numbers in move instructions and as operands of other simple instructions in order to maximize the amount of register tying. This is especially helpful on machines with two-operand instructions. Note -fregmove and -foptimize-register-move are the same optimization. Enabled at levels -O2, -O3, -Os. -fdelayed-branch If supported for the target machine, attempt to reorder instructions to exploit instruction slots available after delayed branch instructions. Enabled at levels -O, -O2, -O3, -Os. -fschele-insns If supported for the target machine, attempt to reorder instructions to eliminate execution stalls e to required data being unavailable. This helps machines that have slow floating point or memory load instructions by allowing other instructions to be issued until the result of the load or floating point instruction is required. Enabled at levels -O2, -O3, -Os. -fschele-insns2 Similar to -fschele-insns, but requests an additional pass of instruction scheling after register allocation has been done. This is especially useful on machines with a rel- atively small number of registers and where memory load instructions take more than one cycle. Enabled at levels -O2, -O3, -Os. -fno-sched-interblock Don’t schele instructions across basic blocks. This is normally enabled by default when scheling before register allocation, i.e. with -fschele-insns or at -O2 or higher. -fno-sched-spec Don’t allow speculative motion of non-load instructions. This is normally enabled by default when scheling before register allocation, i.e. with -fschele-insns or at -O2 or higher. -fsched-spec-load Allow speculative motion of some load instructions. This only makes sense when scheling before register allocation, i.e. with -fschele-insns or at -O2 or higher. -fsched-spec-load-dangerous Allow speculative motion of more load instructions. This only makes sense when scheling before register allocation, i.e. with -fschele-insns or at -O2 or higher. -fsched-stalled-insns -fsched-stalled-insns=n Define how many insns (if any) can be moved prematurely from the queue of stalled insns into the ready list, ring the second scheling pass. -fno-fsched-stalled-insns and -fsched-stalled-insns=0 are equivalent and mean that no insns will be moved prematurely. If n is unspecified then there is no limit on how many queued insns can be moved prema- turely. -fsched-stalled-insns-dep -fsched-stalled-insns-dep=n Define how many insn groups (cycles) will be examined for a dependency on a stalled insn that is candidate for premature removal from the queue of stalled insns. This has an effect only ring the second scheling pass, and only if -fsched-stalled-insns is used and its value is not zero. +-fno-sched-stalled-insns-dep is equivalent to +-fsched-stalled-insns-dep=0. +-fsched-stalled-insns-dep without a value is equivalent to +-fsched-stalled-insns-dep=1. -fsched2-use-superblocks When scheling after register allocation, do use superblock scheling algorithm. Superblock scheling allows motion across basic block boundaries resulting on faster scheles. This option is experimental, as not all machine descriptions used by GCC model the CPU closely enough to avoid unreliable results from the algorithm. This only makes sense when scheling after register

㈥ 在VC6.0中 c++ 怎么用函数去实现关闭编译窗口

1.如果你打开的是模态窗口，在该窗口类执行结束之后加上CDialog::OnCancel;
2.如果你打开的是非模态窗口，在该窗口类执行结束后加上DestroyWindow();
同时重载PostNcDestroy 虚函数，具体操作如下：
void CTestDlg::PostNcDestroy()
{
// TODO: Add your specialized code here and/or call the base class
delete this;
CDialog::PostNcDestroy();
}

㈦ gcc的位域压缩模式，也没有办法，使其通过编译器选项关闭

1下载

的海合会网站（ http://gcc.gnu.org/ 的）或者通过网上搜索可以找到下载资源。目前的GCC 3.4.0的最新版本。该文件是可供下载，一般有两种形式：GCC-3.4.0.tar.gz和gcc-3.4.0.tar.bz2，只是不相同的压缩格式，内容完全一样的，你可以下载一个。

2。解压

根据压缩格式，解压以下选择适当的方式（下面的“％”表示命令行提示符）：

％焦油xzvf GCC-3.4.0.tar。广州

或

％bzcat gcc-3.4.0.tar.bz2的焦油xvf命令 -

新一代的gcc-3.4.0这个目录被称为源目录，使用$ {srcdir的}表示它。后来出现在$ {SRCDIR}，其中真正的路径应该更换。 pwd命令用来显示当前路径。

在$ {SRCDIR} / install目录下的GCC有详细的安装说明，可用浏览器打开index.html阅读。

3。建立目标目录

目标目录（使用$ {OBJDIR}表示）是用来存放编译结果的地方。 GCC建议编译后的文件不上的源目录$ {srcdir的]中（虽然这也可），最好是单独存储在另一个目录中，且不能$ {srcdir的}子目录中。

例如，您可以创建一个文件名为gcc构建的目标目录（源目录$ {SRCDIR}是相同的目录）：

％MKDIR GCC构建％CD GCC-

以下操作主要是在目标目录中建立在$ {OBJDIR}。

4。配置

目的是确定配置的GCC编译器安装到哪里（$ {DESTDIR}），然后指定用什么语言支持一些其他的选择。其中，$ {DESTDIR} $“{OBJDIR}不能或$ {SRCDIR}相同的目录。

配置是通过$ {srcdir的}根据配置来完成。它的命令格式（记得用你的真实路径替换$ {DESTDIR}）：

％$ {SRCDIR} /配置的 - prefix = $ {DESTDIR} [其他选项]

例如，如果你想安装GCC 3.4.0进入/ usr/local/gcc-3.4.0的目录下，$ {DESTDIR}意味着这条道路。

在我的机器，我是这样配置：

％。 / gcc-3.4.0/configure的 - 前缀= / usr/local/gcc- 3.4.0 - 启用线程= POSIX - 禁用检查 - 启用 - 长隆 - 主机= I386-redhat的linux的 - 系统 - 启用zlib的语言？= C，C + +，JAVA

GCC安装在/ usr/local/gcc-3.4.0目录下，支持C / C + +和JAVA语言及其他选项，请参见GCC提供的帮助说明。

5。编译

这是一个漫长的过程。在我的机器上（P4-1.6），这个过程花了超过50分钟。

6。安装

执行以下命令来编译的库文件复制到$ {DESTDIR}目录（路径根据您的设置，您可能需要管理员权限）：

％使安装

至此，GCC 3.4.0安装过程就完成了。

6。其他设置

GCC 3.4.0的所有文件，包括命令文件（如gcc，g+ +的），所以库文件目录$ {DESTDIR}，分别存放，如命令文件中的bin目录下，在lib库文件，头文件包括逊色。由于该命令文件和库文件所在的目录不包含在相应的搜索路径，它是必要的，以进行适当的设置后，编译器可以成功地找到并使用它们。

6.1 GCC，G+ +，gcj的设置

要使用命令如GCC 3.4.0的gcc，最简单的方法是把它的路径$ {DESTDIR} / bin中放置在PATH环境变量。我不知道这种方式，但与符号链接的方式来实现这样做的好处，所以我仍然可以使用旧的系统，原始版本的GCC编译器。

首先，查看原来的gcc所在的路径：

％GCC

在我的系统中，该命令将显示:/ usr / bin中/海湾合作委员会。因此，原来的gcc命令在/ usr / bin目录下。我们可以把GCC 3.4.0的gcc，g+ +的，GCJ和其他命令在/ usr / bin目录下，分别创建一个符号链接：

％CD / usr / bin中

％ LN - S $ {DESTDIR} / bin中/ GCC gcc34

％LN-S $ {DESTDIR} / bin中/ G+ + G+ 34

％LN-S $ {DESTDIR】/ BIN / gcj的gcj34 BR p>因此，可以单独使用gcc34，G+ 34，gcj34的调用GCC 3.4.0的gcc，G+ +，gcj的完成了C，C + +，JAVA程序的编译。虽然仍然可以使用旧版本的GCC编译器在gcc，g+ +的其他命令。

6.2库路径设置
$ {DESTDIR} / lib路径LD_LIBRARY_PATH环境变量，它是最好添加到系统的配置文件，所以它是没有必要的每一个的设置此环境变量。

例如，如果GCC 3.4.0安装在/ usr/local/gcc-3.4.0目录下，在RH Linux可以直接运行在命令行或在文件/ etc /配置文件在这里补充一个：

SETENV LD_LIBRARY_PATH / usr/local/gcc-3.4.0/lib：$ LD_LIBRARY_PATH

7。测试

随着新的编译命令（gcc34，G+ +34等）编译你以前的C，C + +程序来测试新安装的GCC编译器能正常工作。

8。根据需要，可以删除或保留$ {SRCDIR} $ {OBJDIR}目录。

如果您正在使用Ubuntu或Fedora的，那么你可以将它安装直接在源

㈧ C++中Release版本和DEBUG版本编译选项差别的问题。

你是不是有变量没有初始化或者用了诸如i=i++ + ++i这种未定义行为！这两种情况必须考虑！尽量别去考虑debug和release的内存分配方式！

㈨ 我在打开一个网页的时候出现了“您的浏览器不支持Javaacript或关闭了Java编译器 ”

这些网页中有Javaacript脚本
你的浏览器可能是IE5.0或是更早的版本，也没有升级过。
你可以尝试更新IE浏览器
或是点开IE的选项中，在高级中设置。