小编Ale*_*Dan的帖子

我知道当函数定义对于性能来说很小并且节省编译时间时,将函数(正常函数而不是类中的方法)声明为内联是一种很好的做法.但是如何在类中内联方法我不理解类内部方法的概念？如何定义它们以及它们如何工作.

我将一个函数定义show()为在调用的头文件中内联ex.h并定义函数内部ex.cpp.我希望这会给我一个错误,因为编译器不知道在show()调用函数的地方要替换什么.但是因为我使用的是IDE,它运行正常.怎么会发生这种情况？

而BTW当我尝试手动编译它时,它给了我一个错误,show()使用但未定义.

我知道例如"hello"是类型const char*.所以我的问题是:

1. 我们如何分配像"hello"这样的非字符串const char*:

   char* s = "hello";  // "hello" is type of const char* and s is char*
                       // and we know that conversion from const char* to
                       // char* is invalid
   

   Run Code Online (Sandbox Code Playgroud)

2. 是一个文字字符串"hello",它将在我的所有程序中占用内存,或者就像临时变量在语句结束时会被销毁？

在32位机器上sizeof,即使它是对double的引用,我总是得到4个字节的引用,所以它真正存储在这4个字节中.

编辑:

class A{
public:
  double&  a;
};

int main(){
  cout << sizeof(A) << endl; // this will print out 4
}

我试图在命名空间之外定义一个类朋友函数,如下所示:

namespace A{
class window{
    private:
    int a;
    friend void f(window);
};
}

 void f(A::window rhs){
 cout << rhs.a << endl;
}

我得到一个错误说有歧义.有两个候选人void A::f(A::window);和void f(A::window).所以我的问题是:

1)如何使全局函数void f(A::window rhs)成为类A :: window的朋友.

编辑:(阅读答案后)

2)为什么我需要通过操作来限定窗口类中的成员函数f是全局的::f(window)？

3)为什么我需要在这种特殊情况下预先声明函数f(A :: window),而当该类不是在命名空间中定义时,它是在函数被声明为朋友之后声明的函数的okey.

我想知道如何创建异常对象？以及为什么处理函数参数可以是非const引用？

例如:

class E{
    public:
    const  char * error;
    E(const char* arg):error(arg){
    cout << "Constructor of E(): ";}

    E(const E& m){
        cout << "Copy constructor E(E& m): " ;
       error=m.error;
    }
};



int main(){
try{
    throw E("Out of memory");

}
catch(E& e){cout << e.error;}

}

输出: E()的构造函数:内存不足

所以我有throw E("out of memory")和E("out of memory")仅仅是一个临时对象,没有对象被创建除外E("out of memory"),因为没有拷贝构造函数被调用.所以即使这E("out of memory")只是一个临时对象,我有一个非const引用的处理程序.

你能解释一下为什么这是可能的吗？

可能重复:
const引用是否延长了临时的寿命？

假设我有一个功能 f:

int f(int x){return x;}

const int &a=f(1);

我知道这f(1)只是暂时的,我会在这个声明后被销毁,但是

1. 是否使参考const给f(1)一个长寿命？
2. 如果是的话,哪里f(1)会被存储？
3. 这是否意味着x当它超出范围时也没有被破坏？
4. f(1)和之间有什么区别x？

关于这个代码,我有两个问题:

namespace A { class window; }

void f(A::window);

namespace A
{
    class window
    {
    private:
       int a;
       friend void ::f(window);
    };
}

void f(A::window rhs)
{
    std::cout << rhs.a << std::endl;
}

1)为什么我需要通过执行:: f(window)来限定窗口类中的成员函数f是全局的？

2)为什么我需要在这种特殊情况下预先声明函数f(A :: window),而当在类名称空间内没有定义类时,可以在函数声明为朋友之后声明函数.

码:

struct A{
    int a;
    virtual void f(){}
};
union B{
    A ob;
};

编译时错误:

C:\to\main.cpp|9|error: member 'A B::ob' with constructor not allowed in union|
C:\to\main.cpp|9|error: member 'A B::ob' with copy assignment operator not allowed in union|
||=== Build finished: 2 errors, 0 warnings ===|

c ++ 03标准:

具有非平凡构造函数(12.1),非平凡复制构造函数(12.8),非平凡析构函数(12.4)或非平凡复制赋值运算符(13.5.3,12.8)的类的对象不能是一个联盟的成员,也不是一系列这样的对象.如果联合包含静态数据成员或引用类型的成员,则该程序格式错误.

该标准没有说明具有虚函数的类的对象,并且从错误中,编译器抱怨我没有使用的构造函数和复制赋值运算符.这是编译器错误吗？我正在使用gcc.

例如,这个函数f定义如下:

int f(int x){return x;}

如你所知你不能分配对这个临时int的引用:

int& rf=f(2);// this will give an error

但如果我重新定义我的函数f如下:

int& f(int x){return x;}
f(2);// so now f(2) is a reference of x, which has been destroyed 

所以我的问题是:编译器怎么能不让你创建一个临时的引用,这个引用将在statment之后被销毁(在第一种情况下为int).另一方面,它允许你创建一个引用f(2),x而编译器知道这个将被销毁之后return.