遇到一个很古怪的问题，C++类static const成员的初始化

在我的文件里有这class NFDuration， NFDuration.h里是这样的:

// A Duration represents the elapsed time between two instants

// as an int64 nanosecond count. The representation limits the

// largest representable duration to approximately 290 years.

class NFDuration

{

public:

    static const int64_t kNanosecond; // = 1LL

    static const int64_t kMicrosecond;// = 1000

    static const int64_t kMillisecond;// = 1000 * kMicrosecond

    static const int64_t kSecond; // = 1000 * kMillisecond

    static const int64_t kMinute; // = 60 * kSecond

    static const int64_t kHour; // = 60 * kMinute

public:

    NFDuration();

    explicit NFDuration(const struct timeval& t);

    explicit NFDuration(int64_t nanoseconds);

    explicit NFDuration(int nanoseconds);

    explicit NFDuration(double seconds);

    // Nanoseconds returns the duration as an integer nanosecond count.

    int64_t Nanoseconds() const;

    // These methods return double because the dominant

    // use case is for printing a floating point number like 1.5s, and

    // a truncation to integer would make them not useful in those cases.

    // Seconds returns the duration as a floating point number of seconds.

    double Seconds() const;

    double Milliseconds() const;

    double Microseconds() const;

    double Minutes() const;

    double Hours() const;

    struct timeval TimeVal() const;

    void To(struct timeval* t) const;

    bool IsZero() const;

    bool operator<(const NFDuration& rhs) const;

    bool operator<=(const NFDuration& rhs) const;

    bool operator>(const NFDuration& rhs) const;

    bool operator>=(const NFDuration& rhs) const;

    bool operator==(const NFDuration& rhs) const;

    NFDuration operator+=(const NFDuration& rhs);

    NFDuration operator-=(const NFDuration& rhs);

    NFDuration operator*=(int ns);

    NFDuration operator/=(int ns);

private:

    int64_t ns_; // nanoseconds

};

#include "NFDuration.in.h"

在NFDuration.in.h里

#pragma once

inline NFDuration::NFDuration()

    : ns_()

{

}

inline NFDuration::NFDuration(const struct timeval& t)

    : ns_(t.tv_sec * kSecond + t.tv_usec * kMicrosecond)

{

}

inline NFDuration::NFDuration(int64_t nanoseconds)

    : ns_(nanoseconds)

{

}

inline NFDuration::NFDuration(int nanoseconds)

    : ns_(nanoseconds)

{

}

inline NFDuration::NFDuration(double seconds)

    : ns_((int64_t)(seconds * kSecond))

{

}

inline int64_t NFDuration::Nanoseconds() const

{

    return ns_;

}

inline double NFDuration::Seconds() const

{

    return double(ns_) / kSecond;

}

inline double NFDuration::Milliseconds() const

{

    return double(ns_) / kMillisecond;

}

inline double NFDuration::Microseconds() const

{

    return double(ns_) / kMicrosecond;

}

inline double NFDuration::Minutes() const

{

    return double(ns_) / kMinute;

}

inline double NFDuration::Hours() const

{

    return double(ns_) / kHour;

}

inline bool NFDuration::IsZero() const

{

    return ns_ == ;

}

inline struct timeval NFDuration::TimeVal() const

{

    struct timeval t;

    To(&t);

    return t;

}

inline void NFDuration::To(struct timeval* t) const

{

    t->tv_sec = (long)(ns_ / kSecond);

    t->tv_usec = (long)(ns_ % kSecond) / (long)kMicrosecond;

}

inline bool NFDuration::operator<(const NFDuration& rhs) const

{

    return ns_ < rhs.ns_;

}

inline bool NFDuration::operator<=(const NFDuration& rhs) const

{

    return ns_ <= rhs.ns_;

}

inline bool NFDuration::operator>(const NFDuration& rhs) const

{

    return ns_ > rhs.ns_;

}

inline bool NFDuration::operator>=(const NFDuration& rhs) const

{

    return ns_ >= rhs.ns_;

}

inline bool NFDuration::operator==(const NFDuration& rhs) const

{

    return ns_ == rhs.ns_;

}

inline NFDuration NFDuration::operator+=(const NFDuration& rhs)

{

    ns_ += rhs.ns_;

    return *this;

}

inline NFDuration NFDuration::operator-=(const NFDuration& rhs)

{

    ns_ -= rhs.ns_;

    return *this;

}

inline NFDuration NFDuration::operator*=(int n)

{

    ns_ *= n;

    return *this;

}

inline NFDuration NFDuration::operator/=(int n)

{

    ns_ /= n;

    return *this;

}

在NFDuration.cpp里是这样初始化的:

#include "NFDuration.h"

const int64_t NFDuration::kNanosecond = 1LL;

const int64_t NFDuration::kMicrosecond =  * kNanosecond;

const int64_t NFDuration::kMillisecond =  * kMicrosecond;

const int64_t NFDuration::kSecond =  * kMillisecond;

const int64_t NFDuration::kMinute =  * kSecond;

const int64_t NFDuration::kHour =  * kMinute;

3个文件这样写，在windows,linux系统上使用后，编译都没有问题，但是我觉得NFDuration.in.h这个文件麻烦，就把NFDuration.in.h里的东西移到了NFDuration.h里

class NFDuration

{

public:

    static const int64_t kNanosecond; // = 1LL

    static const int64_t kMicrosecond;// = 1000

    static const int64_t kMillisecond;// = 1000 * kMicrosecond

    static const int64_t kSecond; // = 1000 * kMillisecond

    static const int64_t kMinute; // = 60 * kSecond

    static const int64_t kHour; // = 60 * kMinute

public:

    NFDuration();

    explicit NFDuration(const struct timeval& t);

    explicit NFDuration(int64_t nanoseconds);

    explicit NFDuration(int nanoseconds);

    explicit NFDuration(double seconds);

    // Nanoseconds returns the duration as an integer nanosecond count.

    int64_t Nanoseconds() const;

    // These methods return double because the dominant

    // use case is for printing a floating point number like 1.5s, and

    // a truncation to integer would make them not useful in those cases.

    // Seconds returns the duration as a floating point number of seconds.

    double Seconds() const;

    double Milliseconds() const;

    double Microseconds() const;

    double Minutes() const;

    double Hours() const;

    struct timeval TimeVal() const;

    void To(struct timeval* t) const;

    bool IsZero() const;

    bool operator<(const NFDuration& rhs) const;

    bool operator<=(const NFDuration& rhs) const;

    bool operator>(const NFDuration& rhs) const;

    bool operator>=(const NFDuration& rhs) const;

    bool operator==(const NFDuration& rhs) const;

    NFDuration operator+=(const NFDuration& rhs);

    NFDuration operator-=(const NFDuration& rhs);

    NFDuration operator*=(int ns);

    NFDuration operator/=(int ns);

private:

    int64_t ns_; // nanoseconds

};

inline NFDuration::NFDuration()

    : ns_()

{

}

inline NFDuration::NFDuration(const struct timeval& t)

    : ns_(t.tv_sec * kSecond + t.tv_usec * kMicrosecond)

{

}

inline NFDuration::NFDuration(int64_t nanoseconds)

    : ns_(nanoseconds)

{

}

inline NFDuration::NFDuration(int nanoseconds)

    : ns_(nanoseconds)

{

}

inline NFDuration::NFDuration(double seconds)

    : ns_((int64_t)(seconds * kSecond))

{

}

inline int64_t NFDuration::Nanoseconds() const

{

    return ns_;

}

inline double NFDuration::Seconds() const

{

    return double(ns_) / kSecond;

}

inline double NFDuration::Milliseconds() const

{

    return double(ns_) / kMillisecond;

}

inline double NFDuration::Microseconds() const

{

    return double(ns_) / kMicrosecond;

}

inline double NFDuration::Minutes() const

{

    return double(ns_) / kMinute;

}

inline double NFDuration::Hours() const

{

    return double(ns_) / kHour;

}

inline bool NFDuration::IsZero() const

{

    return ns_ == ;

}

inline struct timeval NFDuration::TimeVal() const

{

    struct timeval t;

    To(&t);

    return t;

}

inline void NFDuration::To(struct timeval* t) const

{

    t->tv_sec = (long)(ns_ / kSecond);

    t->tv_usec = (long)(ns_ % kSecond) / (long)kMicrosecond;

}

inline bool NFDuration::operator<(const NFDuration& rhs) const

{

    return ns_ < rhs.ns_;

}

inline bool NFDuration::operator<=(const NFDuration& rhs) const

{

    return ns_ <= rhs.ns_;

}

inline bool NFDuration::operator>(const NFDuration& rhs) const

{

    return ns_ > rhs.ns_;

}

inline bool NFDuration::operator>=(const NFDuration& rhs) const

{

    return ns_ >= rhs.ns_;

}

inline bool NFDuration::operator==(const NFDuration& rhs) const

{

    return ns_ == rhs.ns_;

}

inline NFDuration NFDuration::operator+=(const NFDuration& rhs)

{

    ns_ += rhs.ns_;

    return *this;

}

inline NFDuration NFDuration::operator-=(const NFDuration& rhs)

{

    ns_ -= rhs.ns_;

    return *this;

}

inline NFDuration NFDuration::operator*=(int n)

{

    ns_ *= n;

    return *this;

}

inline NFDuration NFDuration::operator/=(int n)

{

    ns_ /= n;

    return *this;

}

这个时候在wondows上使用后编译时没有问题的，但是在Linux上老是报static const成员没有定义的错误, 于是我把初始化写的类里面，把NFDuration.cpp里的东西删掉, NFDuration.h变成了这样

class NFDuration

{

public:

    static const int64_t kNanosecond = 1LL;

    static const int64_t kMicrosecond = ;

    static const int64_t kMillisecond =  * kMicrosecond;

    static const int64_t kSecond =  * kMillisecond;

    static const int64_t kMinute =  * kSecond;

    static const int64_t kHour =  * kMinute;

.........................

其余与上面一样

然后就发现，在Linux上是没有问题了，但是在windows上又报static const成员没有定义, 这是咋回事啊，网上搜索也没有找到答案，最后只好又恢复成文字刚开始3个文件的样子，貌似只有这样才没有问题，两个系统都能编译，只是原因想不通

找了很久终于找到原因了，娘的啊。。。。。。。。。。。。。。。。。。。。。。。。

终于找到原因了，所有的问题都找错了，不管怎么样写其实都没有问题，真正的问题是timeval这个数据结构的，没法支持跨平台，而linux系统的编译器老是误报，没有吧问题真正的原因暴露出来，timeval我也不知道怎么做到快平台，最后只好加上libevent的头文件，

解决了这个问题。本来想删掉这文章的，想想留住纪念吧！！

巴特西

遇到一个很古怪的问题，C++类static const成员的初始化

最新文章

热门文章