C++ 否./a.out生产于g++；

我有以下计划：

#include "Sptr.cpp"
#include <iostream>
#include <stdio.h>
#include <assert.h>

namespace my {
    template <class T>
    class Sptr {
    private:
        //some kind of pointer
            //one to current obj
        T obj;
        size_t reference_count;
            //one to original obj
    public:
        Sptr();

        template <typename U> 
        Sptr(U *);

        Sptr(const Sptr &);

        template <typename U> 
        Sptr(const Sptr<U> &);

        template <typename U> 
        Sptr<T> &operator=(const Sptr<U> &);

        void reset();

        T* operator->() const
        {return &obj;};

        T& operator*() const
        {return obj;};

        T* get() const
        {return &obj;};

        //operator unspecified_bool_type() const;

        //overload *,->,=,copy-constructor

        // const-ness should be preserved.
        // Test for null using safe-bool idiom
        // Static casting, returns a smart pointer
    };

    template <typename T>
    Sptr<T>::Sptr() {
        //do something
    }

    template <typename T>
    template <typename U> 
    Sptr<T>::Sptr(U* u) {
        //do something
    }

    template <typename T> 
    Sptr<T>::Sptr(const Sptr<T> &copyObj) {
        //do copy constructor stuff
    }

    template <typename T> 
    template <typename U> 
    Sptr<T>& Sptr<T>::operator=(const Sptr<U> &t) {
        return *this;
    }

    template <typename T>
    void Sptr<T>::reset() {
        //do something
    }

    template <typename T1, typename T2>
    bool operator==(const Sptr<T1> &, const Sptr<T2> &) {
        //do something
        return true;
    }

    template <typename T, typename U>
    Sptr<T> static_pointer_cast(const Sptr<U> &sp) {
        //do something
        return true;
    }

    template <typename T, typename U>
    Sptr<T> dynamic_pointer_cast(const Sptr<U> &sp) {
        //Do something
        return true;
    }
}


using namespace std;
using namespace my;
/* Basic Tests 1 ================================================================================ */

class Base1 {
    protected:
        Base1() : derived_destructor_called(false) {
            printf("Base1::Base1()\n");
        }
    private:
        Base1(const Base1 &); // Disallow.
        Base1 &operator=(const Base1 &); // Disallow.
    protected:
        ~Base1() {
            printf("Base1::~Base1()\n");
            assert(derived_destructor_called);
        }
    protected:
        bool derived_destructor_called;
};

class Derived : public Base1 {
        friend void basic_tests_1();
    private:
        Derived() {}
        Derived(const Derived &); // Disallow.
        Derived &operator=(const Derived &); // Disallow.
    public:
        ~Derived() {
            printf("Derived::~Derived()\n");
            derived_destructor_called = true;
        }
        int value;
};

void basic_tests_1() {

}

int main(int argc, char *argv[]) {

    cout << "Hello world";
    basic_tests_1();

    return 0;
}

没有创建二进制文件的问题是什么？我的g++版本是4.7，我运行的是Ubuntu 12.10

PS：一个简单的hello world程序可以工作

---

如果我将文件从.hpp重命名为.cpp，它将正确编译

注意：所有代码都在一个文件中。另一个文件是空的

为什么会这样

编辑：

@teppic提到了这一点

---

它将生成一个预编译的头文件，而不是一个可执行文件

从gcc手册：

   file.hh
   file.H
   file.hp
   file.hxx
   file.hpp
   file.HPP
   file.h++
   file.tcc
   C++ header file to be turned into a precompiled header or Ada spec.

i、 分机错了

如果检查文件类型，则确认：

$ g++ -o foo foo.hpp
$ file foo
foo: GCC precompiled header (version 013) for C++

从gcc手册：

   file.hh
   file.H
   file.hp
   file.hxx
   file.hpp
   file.HPP
   file.h++
   file.tcc
   C++ header file to be turned into a precompiled header or Ada spec.

i、 分机错了

如果检查文件类型，则确认：

$ g++ -o foo foo.hpp
$ file foo
foo: GCC precompiled header (version 013) for C++

---

您正在编译一个包含

.cpp

文件的

.hpp

文件。这不应该是另一种情况吗？@mfontani-hmm可能是真的，从逻辑上讲，我没有注意到这些名字。但我确信我编写的内容是正确的。因为如果我只是注释掉除hello world之外的所有内容，它会打印出来。它会生成一个预编译的头文件，而不是一个可执行文件。您正在编译一个

.hpp

文件，其中包含一个

.cpp

文件。这不应该是另一种情况吗？@mfontani-hmm可能是真的，从逻辑上讲，我没有注意到这些名字。但我确信我编写的内容是正确的。因为如果我只是注释掉除hello world之外的所有内容，它就会打印出来。它会生成一个预编译的头文件，而不是一个可执行文件。