最初,我认为static并且inline意味着以下功能:
警告:这是我以前认为的,不要认为这是正确的.
一个static函数只存在一次.使用它的一切都使用相同的功能.*
一个inline函数的内容,据推测,复制到调用函数.编译器实际上可能忽略了这一点,但是如果在非模板头文件中定义,则必须避免重复定义.
一个static inline功能,我仍然没有弄清楚这应该是什么意思.
*添加了注释,类模板有效地生成类,因此它们的静态内容对于每个派生类型是完全不同的.
我从C++ for Java Programmers一书中得到了这个印象(Mark Allen Weiss,ISBN 0-13-919424-X).在第2.1.6段,它说:
在某些情况下,进行函数调用的开销可能很大.例如,max2例程是微不足道的,因此可能只想简单地用main2逻辑上执行的代码替换main中的函数调用:...当然,这将牺牲良好的编程实践来提高速度.
为避免这种情况,可以使用内联指令.内联指令建议编译器应该生成避免函数定义开销的代码......
令人惊讶的是,我找不到任何关于static功能的信息.它可能在那里,但我在索引中找不到它.
但后来我找到了这个答案,似乎正好相反:
非静态内联函数声明在使用它的每个转换单元(源文件)中引用相同的函数.
和
如果它是静态的,则每个TU都有自己的函数版本,因此它有自己的静态局部变量副本.
这个答案似乎采取了不同的立场inline,同意我原来的解释:
inline准确传达了你想要的东西:"请为这个函数抑制ODR规则,这样每个翻译单元都可以(并且必须)提供它自己的函数定义副本".
但后来继续说一个inline函数可以内联(我假设这意味着重复到它被调用的每个地方)或合并在一起.
然后,编译器将内联对函数的调用,或者将来自不同TU的函数定义合并在一起(以便生成的函数在可执行文件中存在一次).
然后它还说声明一个函数static意味着将存在任意数量的函数:
另一方面,static告诉编译器在定义它的每个转换单元中生成函数,而不是共享它.因此,您最终会在生成的可执行文件中存在任意数量的技术上独立的函数.
我不确定,但它听起来像static函数不止一次存在并且inline函数,当编译器实际执行内联时,只存在一次.这与我以前的想法完全相反.
但最重要的是,这里有一堆关于单身人士的问题,其中声明了每个getInstance函数static:
因此,如果static函数确实存在多次,这实际上意味着将存在多个本地static单例对象,并且我看到的每个C++单例示例都是错误的,这似乎不太可能.
我不再理解了.一切似乎都暗示着别的东西.是什么static,inline以及,作为奖励:static inline真的意味着功能？
你记得在算法中的本科讲座中,有一个概念是非常方便的Nil,可以分配或比较任何东西.(顺便说一下,我从未在计算机科学专业读过本科生.)在Python中我们可以使用None; 在Scala中有Nothing(如果我正确地理解它,它是所有东西的子对象).但我的问题是,我们如何才能拥有NilC++？以下是我的想法.
我们可以使用Singleton设计模式定义单个对象,但我目前的印象是,大多数人都会在想到这一点时畏缩.
或者我们可以定义全局或静态.
我的问题是,在这两种情况中,我都想不出能够将任何类型的任何变量分配给Nil或能够比较任何类型的任何对象的方法Nil.Python None是有用的,因为Python是动态类型的; Scala Nothing(不要与Scala混淆Nil,这意味着空列表)优雅地解决了这个问题,因为它Nothing是一切的子对象.那么Nil在C++中有一种优雅的方式吗？
这是策略界面的外观
public interface Strategy
{
public void doStuff(Object o);
}
这是一个可能的实现
public class StrategyImpl implements Strategy
{
@Override
public void doStuff(Object o)
{
//Do things with o
}
}
现在，使用StrategyImpl实现可能有数百个对象。应该为所有这数百个对象创建一个StrategyImpl的新实例，还是有更好的方法？
我在这里已经读过，不应使用单例来节省内存，但是似乎没有必要创建数百个相同的实例。也许最好的解决方案不是单例，而是某种方式。
我应该如何制定策略？我是否应该不理会这些类型的问题？
我只需要在某处阅读以下代码:
public class SingletonObjectDemo {
private static SingletonObjectDemo singletonObject;
// Note that the constructor is private
private SingletonObjectDemo() {
// Optional Code
}
public static SingletonObjectDemo getSingletonObject() {
if (singletonObject == null) {
singletonObject = new SingletonObjectDemo();
}
return singletonObject;
}
}
我需要知道这部分需要什么:
if (singletonObject == null) {
singletonObject = new SingletonObjectDemo();
}
如果我们不使用这部分代码怎么办？仍然会有一个副本SingletonObjectDemo,为什么我们需要这个代码呢？
在实现工厂类时,我遇到了std::auto_ptr一些我无法理解的行为.我将问题减少到下面的小程序,所以......让我们开始吧.
考虑以下单例类:
singleton.h
#ifndef SINGLETON_H_
#define SINGLETON_H_
#include<iostream>
#include<memory>
class singleton {
public:
static singleton* get() {
std::cout << "singleton::get()" << std::endl;
if ( !ptr_.get() ) {
std::cout << &ptr_ << std::endl;
ptr_.reset( new singleton );
std::cout << "CREATED" << std::endl;
}
return ptr_.get();
}
~singleton(){
std::cout << "DELETED" << std::endl;
}
private:
singleton() {}
singleton(const singleton&){}
static std::auto_ptr< singleton > ptr_;
//static std::unique_ptr< singleton > ptr_;
};
#endif
singleton.cpp
#include<singleton.h>o
std::auto_ptr< singleton > singleton::ptr_(0);
//std::unique_ptr< singleton > …我有一个sinlgeton对象,它持有一个方法,巫婆不同步.单个用户可以一次访问单例 - 如果多个客户端访问该对象会发生什么？是否会以先来先服务的方式提供对象引用...也就是说,一个客户端是否必须等待第一个完成对象,或者它将在内存中被赋予相同的对象引用？
我对单例中未同步的方法感到奇怪.如果2个客户端使用不同的参数调用Singleton.method(param) - 它们不会为彼此创建问题吗？
对于大多数C++项目,Boost涵盖了很多基础组件,但经常使用的解决方案和习惯用法需要一些锅炉板或地面工作.您认为在每个项目中拥有它并因此将它放在一个小的"库"中是如此重要？我想到的一些事情:
(最后两个是在Loki,但Loki与Boost重叠,人们对使用它犹豫不决.)
编辑:我可能应该补充一点,我不询问标准库的常用扩展,例如copy_if.
为了简单起见，我保留了其余的实现，因为它与这里无关。考虑现代 C++ 设计中描述的双重检查查找的经典实现。
Singleton& Singleton::Instance()
{
if(!pInstance_)
{
Guard myGuard(lock_);
if (!pInstance_)
{
pInstance_ = new Singleton;
}
}
return *pInstance_;
}
在这里，作者坚持我们要避免竞争条件。但我读过一篇文章，不幸的是我不太记得了，其中描述了以下流程。
在那篇文章中，作者指出，技巧是可以在线 pInstance_ = new Singleton;分配内存，并将其分配给 pInstance，以便在该内存上调用构造函数。
依靠标准或其他可靠来源，任何人都可以确认或否认此流程的可能性或正确性吗？谢谢！
我已经实现了一个使用查找表的快速比较功能.由于此函数在项目的多个类中使用,我需要确保在整个程序执行期间只有一个查找表副本.
查找表是一个简单vector<int>的大小65536.我希望这个表在程序开始时初始化,而不是在它第一次使用时.如何处理这个问题？
以下代码段是我的比较函数的当前版本.我相信通过创建lookup_table一个静态变量,问题将只能部分解决,因为静态变量的生命周期是在程序流第一次遇到声明时开始的.
int fast_compare(const char* array1, const char* array2, int length)
{
static const vector<int> lookup_table = init_lookup_table();
// process the input arrays...
// ...
return lookup_table[...];
}
vector<int> init_lookup_table()
{
vector<int> lut(65536);
// ----------------------------
// initialize the look-up table
// ...
// ...
// end of initialization
// ----------------------------
return lut;
}
我知道C++也允许创建类和结构的全局对象.
#include <iostream>
using std::cout;
class Test
{
public:
void fun()
{
cout<<"a= "<<a;
}
private:
int a=9;
};
Test t; // global object
int main()
{
t.fun();
return 0;
}
何时何地我应该使用全局对象？全局对象是否有特定用途？请帮我.