例如,我有以下课程:
class singelton
{
public:
static singelton* Instance()
{
if (m_pInstance == 0)
{
m_pInstance = new singelton();
}
return m_pInstance;
}
void setData(std::string input) { data = input; }
void getData() const { std::cout << data << std::endl; }
private:
singelton() {}
~singelton() {}
static singelton* m_pInstance;
std::string data;
};
typedef singelton s;
//what is this? Why need a singleton name? I mean "singelton*".
singelton* singelton::m_pInstance = 0;
int main(int argc, char** argv)
{
s.Instance()->setData("Something...");
s.Instance()->getData();
return 0;
} …我有连接池的singelton.
public enum ConnectionPool {
INSTANCE;
private DataSource ds = null;
ConnectionPool() {
try {
final Context initCtx = new InitialContext();
ds = (DataSource) initCtx.lookup("java:comp/env/jdbc/test");
} catch (NamingException e) {
e.printStackTrace();
}
}
public Connection getConnection() throws SQLException {
return ds.getConnection();
}
}
我应该同步getConnection()以防止从不同的线程获取相同的实例吗？它看起来已经被Tomcat同步了,但我不确定(我使用的是Tomcat 8).
嗨，我有一个代码片段，它是一个单例类（我相信），它以以前从未见过的方式使用'new'和其他一些作用域和静态限定符。因为我不知道它叫什么，所以找不到有关它的用途或目的的任何信息。代码如下：
在myClass.h文件中
class myClass
{
private:
static myClass sm_myClass;
myClass();
public:
static void Create(void);
};
在myClass.cpp中，我有
#include "myClass.h"
#include <new>
myClass* p_myClass = NULL;
myClass myClass::sm_myClass;
myClass::myClass()
{
}
void myClass::Create(void)
{
p_myClass = &sm_myClass;
new (p_myClass) myClass();
}
我的问题是：
1-.cpp文件的第6行（myClass myClass :: sm_myClass;）发生了什么
2-.cpp文件的第16行（new（p_myClass）myClass（）;）发生了什么
3-以这种方式使用类的总体目的是什么？
我真的希望这个问题不再重复。我搜索了一段时间，但不知道要搜索什么词。谢谢你的帮助。
我有一个具有静态函数的类,其中返回类的实例.
我只是想知道这是不好的做法.
public class Foo()
{
public int FooInt {get; private set;}
public string FooString {get; private set;}
public static Foo GetFoo()
{
Foo foo = new Foo();
foo.FooInt = 5;
foo.FooString = "Test";
return foo;
}
}
我正在尝试将我之前在 PHP 和 Java 8 中使用过的单例实现到 C++。但我确实面临语法和 C++ 工作方式（特别是指针）的某些限制。
这是我迄今为止尝试过的：
#include "iostream"
using namespace std;
class System{
protected:
static System *obj;
public:
static System *getInstance(){
return obj;
}
void prn(){
cout<<"this works!";
}
};
int main(void){
System &sys = System::getInstance();
sys.prn();
}
执行时，我收到以下错误：
sameer.cpp:20:10: error: non-const lvalue reference to type 'System'
cannot bind
to a temporary of type 'System *'
System &sys = System::getInstance();
^ ~~~~~~~~~~~~~~~~~~~~~
请帮我解决这个错误..因为我不知道它是什么意思。我在发帖前检查了论坛，它可能与之前提出的问题（我找不到）重复。但我发帖是因为我想了解我的代码生成的错误的含义。
谢谢您的帮助
我为各种平台编写应用程序,但主要是OS X和Windows.在这两方面,我受到了测试驱动开发(TDD),SOLID等最近趋势的影响.我发现大多数都是很好的建议.我发现如果我有很好的测试覆盖率,我更有可能根据需要进行重构,因为我更有信心我会在测试中发现重构的任何副作用.
无论如何,所有这一切都引出了我的问题:"经理"单身总是一个坏主意吗？我正在编写一个Cocoa应用程序,它必须处理队列中的大量QuickTime文件.应用程序中只能有一个队列,并且应该可以访问应用程序的多个部分,以便它们可以将项目添加到队列中.我发现最简单的方法是使用单例.现在,我已经注意以可测试的方式编写这个单例,因此TDD不是问题.
在这种情况下,我会用什么替代单身人士？还有哪些其他设计模式可以进行单元测试？(请注意,此问题应视为与语言无关.这是一般的OO和TDD问题.)
我有点麻烦这样在java中工作:
public class ClassA {
public static ClassB PointerToB;
public static ClassC PointerToC;
public ClassA() {
PointerToB = new ClassB();
PointerToC = new ClassC();
PointerToB.doSthB();
}
}
public class ClassB {
public void doSthB() {
ClassA.PointerToC.doSthC();
}
}
public class ClassC {
public void doSthC() {
// ...
}
}
说我有这些课程,我的"主"班("A")有几个成员.这些指向其他对象("B","C")的指针是静态的,因此"B"中的代码可以访问"C"中的(非静态)方法.
我知道静态方法只能访问其他静态方法和/或变量,但由于对这些类的引用是静态的 - 而不是实际的类本身 - 它应该以这种方式工作 - 不应该吗？
我有点卡在这里,因为这种访问一直崩溃我的应用程序:(
我需要ClassB来访问ClassC中的(非静态)方法,而不传递对A或C的所有引用.我该怎么做呢？
我正在创建一个全局静态对象,将在整个应用程序中使用.我将在delegates/threads中使用成员函数.这种方法有潜在的缺陷吗？
我再一次在这里寻求支持.
例如,我有一个名为fp的fopen
FILE * fp;
fp=fopen("Entity.dat","wb");
我有x函数,需要在所有这些函数中使用这个函数,所以问题是如何将它作为公共/全局范围.
下面是使用单例设计模式的类:
class Singleton
{
private static Singleton instance;
private Singleton()
{
...
}
public static synchronized Singleton getInstance()
{
if (instance == null)
instance = new Singleton();
return instance;
}
...
public void doSomething()
{
...
}
}
我想知道关于上述课程的一些设计问题？为什么实例变量是instance私有的和静态的.我知道私有使实例变量只能访问该特定类的对象,但它如何帮助？