标签: compile-time

我们使用Hudson来构建我们的项目,Hudson在编译时方便地定义了像"%BUILD_NUMBER%"这样的环境变量.

我想在代码中使用该变量,因此我们可以在运行时记录这是什么构建.但是我不能做System.Environment.GetEnvironmentVariable,因为那是访问运行时环境,我想要的是这样的:

#define BUILD_NUM = %BUILD_NUMBER%

要么

const string BUILD_NUM = %BUILD_NUMBER%

除了我不知道语法.有人可以指点我正确的方向吗？谢谢!

在C++中,您可以这样做:

static const char * [4] = {
   "One fish",
   "Two fish",
   "Red fish",
   "Blue fish"
};

...这为您提供了一个很好的只读数组数据结构,它不需要在运行时初始化任何CPU周期,因为所有数据都已经为您(在可执行文件的只读存储器页面中)布局了编译器.

但是如果我宁愿使用不同的数据结构而不是数组呢？例如,如果我希望我的数据结构通过密钥快速查找,我必须做这样的事情:

static std::map<int, const char *> map;

int main(int, char **)
{
   map.insert(555, "One fish");
   map.insert(666, "Two fish");
   map.insert(451, "Red fish");
   map.insert(626, "Blue fish");

   [... rest of program here...]
}

...当地图数据结构在运行时被填充时,它不那么优雅且效率较低,即使在编译时已知所有必要的数据,因此该工作可以(理论上)完成.

我的问题是,在C++(或C++ 11)中是否有任何方法可以创建一个只读数据结构(如地图),其数据完全在编译时设置,因此预先填充并准备好在运行时,数组的方式是什么？

假设我有以下简化程序：

链接到godbolt.org：

#include <cassert>

struct Dimensions {

    Dimensions& operator=(int i) {
      assert(i != 0);
      return *this;
    }

};

int getDim();

int main() {
    Dimensions dims;
    dims = getDim();//ok, just use runtime assert
    dims = 0;//compile error wanted here
    return 0;
}

在第一种情况（getDim）中，无法检查编译时，因此我们很高兴在运行时检查它。

但是在理论上看起来可行dims = 0;时，是否也可以通过某种方式检测到编译（对于第二种情况）？（甚至可能带有某种类型的重载或包装？）

如果条件涉及sizeof为真,我想定义一个宏,如果它是假,则不做任何事情(但仍然编译).如果支持预处理器sizeof,它将如下所示:

#if (sizeof(void*) <= sizeof(unsigned int)) // what goes here?
#  define POINTER_FITS_INTO_UINT
#endif

有一些页面(例如http://scaryreasoner.wordpress.com/2009/02/28/checking-sizeof-at-compile-time/)解释如何使一个编译时断言的sizeof(和无法编译,如果它失败了),但我没有看到一种方法将这种方法扩展到我想要的.

我想在编译时加密/编码一个字符串,以便原始字符串不会出现在已编译的可执行文件中.

我已经看过几个例子,但他们不能把字符串文字作为参数.请参阅以下示例:

template<char c> struct add_three {
    enum { value = c+3 };
};

template <char... Chars> struct EncryptCharsA {
    static const char value[sizeof...(Chars) + 1];
};

template<char... Chars>
char const EncryptCharsA<Chars...>::value[sizeof...(Chars) + 1] = {
    add_three<Chars>::value...
};

int main() {   
    std::cout << EncryptCharsA<'A','B','C'>::value << std::endl;
    // prints "DEF"
}

我不想像它那样单独提供每个角色.我的目标是传递一个字符串文字,如下所示:

EncryptString<"String to encrypt">::value

还有一些像这样的例子:

#define CRYPT8(str) { CRYPT8_(str "\0\0\0\0\0\0\0\0") }
#define CRYPT8_(str) (str)[0] + 1, (str)[1] + 2, (str)[2] + 3, (str)[3] + 4, (str)[4] + 5, (str)[5] + …

我正在为Javascript代码编写一些测试,我需要在遇到错误时在编译过程中转储一些消息.

System.out.println()在Javascript中有没有相当于Java的东西？

PS:我还需要在实现测试时转储调试语句.

UPDATE

我在包含所有合并测试的文件上使用maven插件:

        <plugin>
            <groupId>org.codehaus.mojo</groupId>
            <artifactId>exec-maven-plugin</artifactId>
            <version>1.1</version>
            <executions>
                <execution>
                <phase>test</phase>
                <goals>
                    <goal>java</goal>
                </goals>
                </execution>
            </executions>
            <configuration>
                <mainClass>org.mozilla.javascript.tools.shell.Main</mainClass>
                <arguments>
                    <argument>-opt</argument>
                    <argument>-1</argument>
                    <argument>${basedir}/src/main/webapp/html/js/test/test.js</argument>
                </arguments>
            </configuration>
        </plugin>

更新II

我试过了console.log("..."),但我明白了:

js: "src/main/webapp/html/js/concat/tests_all.js", line 147:
uncaught JavaScript runtime exception: ReferenceError: "console" is not defined

我正在测试的代码是一组函数(比如在库中).我正在使用QUnit.

这是本主题的某种后续行动,涉及其中的一小部分.与前一个主题一样,让我们​​考虑一下我们的编译器有和的constexpr函数.现在,让我们直截了当地说.std::initializer_liststd::array

这有效:

#include <array>
#include <initializer_list>

int main()
{
    constexpr std::array<int, 3> a = {{ 1, 2, 3 }};
    constexpr int a0 = a[0];
    constexpr int a1 = a[1];
    constexpr int a2 = a[2];
    constexpr std::initializer_list<int> b = { a0, a1, a2 };

    return 0;
}

这不是:

#include <array>
#include <initializer_list>

int main()
{
    constexpr std::array<int, 3> a = {{ 1, 2, 3 }};
    constexpr std::initializer_list<int> b = { a[0], a[1], a[2] …

我需要实现自包含的编译时函数来检查类型相等(没有参数的函数模板bool eqTypes<T,S>()).

自包含意味着不依赖于图书馆.

我对这一切并不擅长.这就是我尝试过的,但这不是我需要的.

template<typename T>
bool eq_types(T const&, T const&) { 
return true;
}

template<typename T, typename U> 
bool eq_types(T const&, U const&) { 
return false; 
}

我真的找不到任何用途.我的第一个想法是,我可以使用它来实现'按合同设计',而不使用像这样的宏:

struct S
{   
    S(constexpr int i) : S(i) { static_assert( i < 9, "i must be < 9" ); }

    S(int i); //external defintion

    char *pSomeMemory;
};

但这不会编译.我想我们也可以使用它来引用同一变量,而不需要创建额外的内存,当我们想要避免get/setters时,为了使用户的一个成员的实例是只读的:

class S
{  
private:
    int _i;

public:
    const int & constexpr i = _i;
};

但以上都没有实际编译过.有人可以告诉我为什么要引入这个关键字？

首先,通过SBT进行的增量构建非常棒,通常在<1秒范围内.但是,有时您必须进行完全清理/编译,或者在增量构建的情况下,您对一个文件进行更改,然后触发编译其他几十个文件.

这就是Scala开发变得不那么有趣了,因为工作流程的减慢可以鼓励上下文切换(检查电子邮件,最新的Stackoverflow线程等),这会巧妙地降低工作效率

那么,为了改进完整的清理/编译构建,以及(理想情况下)更改一个文件而不重新编译一半应用程序增量构建,需要避免哪些开发方法？

我可以想到的例子:
1)最好有一千个+行全部scala文件,或者几个文件分开？
2)我可以拥有蛋糕(模式)还是会延长构建时间？
3)我可以拥有pimp'd x,y,z库模式,还是更好地找到另一种方式？
4)包装对象(带有隐含)是构建时间杀手吗？
5)嵌套对象和特征？
6)隐含的方法/参数或停止聪明和明确？

具体来说,我正在考虑放弃一个蛋糕模式DAO我提出并整合到ScalaQuery案例类+伴随对象+最小数据库提供程序特征.仅此一项就可以删除20个scala文件.

应用程序足够小(120 scala + 10个java文件)现在重构,没有太多麻烦.显然,随着scala应用程序的增长,构建时间也会增长,仅基于LOC.我只是想看看在哪里修剪脂肪以及在哪里不打扰(即保持原样),因此当前和未来的应用程序将受益于scala提供的表现力,而不会不必要地增加构建时间.

感谢您在构建时间内体验scala开发的好,坏和丑的一些示例.