小编sla*_*ais的帖子

它基本上是一个安装在多台PC上的应用程序,每个安装都维护着它自己的数据库,当它们同时启动时(同时连接到同一网络),它与其他数据库同步.

我已经使用简单的套接字连接和自定义缓冲区对此进行了测试,但是希望使应用程序之间的通信符合公认的标准并且还要安全/健壮,而不是试图重新发明轮子.

这个应用程序到应用程序通信的正常/标准方式是什么？我在哪里可以找到更多信息？

此外,还有/可以使用哪些技术来宣传和查找网络上的其他应用程序？

编辑:(提炼我的问题)

下面的gimel指向的pub/sub模型似乎与我需要的一致.然而,它涵盖了很多方面,我真的不知道从这一切中拿走和使用什么.

看起来我需要在两个或更多应用程序找到彼此后建立P2P连接 - 我该怎么做？

如果有可用的示例/教程,请指出它们.实现类似我需要的东西的小型开源项目/模块也将提供服务.

我选择的平台是Linux,但基于Windows的示例也非常实用.

编辑[09-01-06]:

我目前正在查看以下选项:

1. 多播(TLDP-Howto) - 这似乎可行,但我需要更多地研究它.
2. 使用免费的动态DNS服务器,虽然这看起来有点冒险......
3. 使用一些免费的电子邮件工具,例如gmail/yahoo/...,并从那里发送/读取邮件以查找其他应用程序的IP(可以工作,但感觉很脏)
4. 建议使用webservices,但我不知道它们是如何工作的,并且必须对它进行研究

我很感激您对这些选项的看法以及是否有任何示例.遗憾的是,我没有选择使用中央服务器或网站(除非可以保证免费和永久).

[编辑2009-02-19]

(希望我能接受两个/三个答案!我接受的那个答案因为它提供了思路和可能性,而其他人则提供了固定但适用的解决方案.感谢所有回答的人,所有这些都有帮助.)

当我找到/实现我的解决方案时,我将更新这个问题,如果解决方案足够,我将为它创建一个sourceforge项目.(无论如何,这是一个更大的项目中的一个小问题.)

类中私有变量的引用传递是否可以在该类可接受的实践之外直接更改？或者这是编译器“应该”选择并阻止的东西？

例子：

//-------------------------------------------
class Others
{
public:
 Others() {};
 void ChangeIt(string &str) { str = "Changed by Others"; }
};

//-------------------------------------------
class Locals
{
private:
 string PrivateString;
public:
 Locals() { PrivateString = "Set by Locals"; };
 void VisitOthers() { Others o; o.ChangeIt(PrivateString); }
 const string GetString() { return PrivateString; }
};

//-------------------------------------------
int main(void)
{
 Locals lo;
 cout << lo.GetString() << "\n";
 lo.VisitOthers();
 cout << lo.GetString() << "\n";
 return 0;
}

输出：

Set by Locals
Changed by Others

我需要使用其他/不同的对象来做这样的事情，所有者类私有，但在需要时可由其他人更改。我最不想要的是这种练习在未来回来并给我带来好处。

基本上让我担心的是，我想将类/结构视为基本上指向缓冲区的指针，并将成员地址视为该缓冲区的偏移量，因此即使您传递成员的指针值，它也会没有它所属的类/结构的基指针就没有用。这就是我本能地觉得应该是这样的，所以上面的例子应该是不可能的。

是否有任何方式/ SW-tool可用于监视目录以更改文件,然后将其备份到唯一文件或版本控制系统？

原因:我正在使用Code :: Blocks并进行编辑/测试/更改,偶尔(@#$%!)会希望/需要还原/恢复前一段代码.我希望备份在后台静默发生,这是一个安装和忘记的事情,直到我需要它.理想情况下,每次保存文件时都必须备份文件.

[编辑2010-09-29]

我已经使用了Matthew Iselin的第二个建议(incron)来创建我自己的解决方案,' simplebup ',我在GitHub上开源了.希望它对其他人有用.

谷歌搜索没有找到任何东西.它们是在使用点创建的,还是实例之间共享的通用部分？

(模板类相同吗？)

在下面的代码std::cout中不打印值,但printf确实如此.为什么是这样？

#include <iostream>
#include <cstdio>

struct bits
{
    union
    {
        unsigned char b;
        struct
        {
            unsigned char b0:1, b1:1, b2:1, b3:1, b4:1, b5:1, b6:1, b7:1;
        };
    };
};

const union
{
    bits b[3];
    char c[3];
} CU = { .c = { -1, 0, 1 }};


int main()
{
    std::cout << "----- chars:\n";

    std::cout << "\tstd::cout (c): " << CU.c[0]
                 << ", " << CU.c[1]
                 << ", " << CU.c[2] 
                             << "\n";

    printf("\tprintf (c): %d, %d, …

在下面的代码中,析构函数a被调用两次,并且第一次调用似乎被忽略:

struct A1
{
    int A;
    A1(int a=0) : A(a) { std::cout << "ctor: " << A << "\n"; std::cout.flush(); }
    ~A1() { std::cout << "dtor: " << A << "\n"; std::cout.flush(); }
};


int main()
{
    A1 a(1), *pa=new A1(2), *pb=new A1(3);

    a.~A1();
    pa->~A1();
    delete pb;
    std::cout << "'destructed' a.A = " << a.A << "\n"; std::cout.flush();

    return 0;
}

输出:

ctor: 1
ctor: 2
ctor: 3
dtor: 1
dtor: 2
dtor: 3
'destructed' a.A = 1 …

如何使用C++以编程方式锁定/解锁或以其他方式阻止/启用编辑Linux上的源文件.

我希望能够锁定源文件,这样如果我在编辑器中打开它,它将不允许我保存回相同的源文件.

我想可能将权限更改为只读(并在以后将其更改为读写):我如何从C++中执行此操作？

我的任务是将现有的Java/C++混合Web应用程序转换为纯Java,但是由于缺少只有类文件可用的Java源(.java文件),我受到了阻碍.幸运的是,我不需要在代码中更改任何内容,只需要继续调用方法即可.

我创建了一个新的Java Web应用程序项目(使用Netbeans); 通过复制它的源代码来重新创建applet并让它以骨架方式工作,对源代码和方法的调用没有在源代码中注释掉,但我现在仍然坚持如何添加类文件(缺少的源代码)到这个项目.

(显然我是Java的新手)关于我应该如何进行的任何指示都将受到欢迎.

我发现了我的错误(几个小时后),并在以下程序中将其隔离.问题在于使用指向结构的指针时计算pst2变量值的方式.当使用指向char的指针时,一切正常.为什么是这样？
(使用gcc/g ++版本:( Debian 4.4.5-8)4.4.5)
(对于那些想知道的人:我正在访问包含常规偏移量的数据分组的文件缓冲区.)

#include <iostream>
#include "testpa.h"

#pragma pack(push)
#pragma pack(1)
//---------------------------
struct st_one
{
    int i;
    char c;
};
//---------------------------
struct st_two
{
    long l;
    int i;
};
#pragma pack(pop)

//===========================
int main()
{
    int n=1024, np1=sizeof(st_one); //, np2=sizeof(st_two);
    st_one *pst1, *pst1a;
    st_two *pst2, *pst2a;
    char *pc1, *pc2, *pc1a, *pc2a, *pb;

    pb = new char[n];

    pst1 = (st_one*)(pb);
    pst2 = (st_two*)(pst1 + np1); //using pst1
    pc1 = (char*)(pb);
    pc2 = (char*)(pc1 + np1); //using pc1

    pst1a …

我一直在讨论与前一个问题相关的成员函数指针.在下面的代码中,我调用类(B)上的方法来更改其中的变量(count),但我从不创建此类的实例.为什么这样做？

#include <iostream>
#include <string>
#include <map>

class A;
typedef int (A::*MEMFUNC)(int, int);

#define HANDLER(aclass, aproc) (MEMFUNC)(&aclass::aproc)

enum
{
    ADD=1,
    MUL,
    SUB,
    DIV
};

class B
{
    int count;
public:
    B() : count(0) {}
    ~B() {}
    int multiply(int x, int y) { count++; return x*y*count; }
    int divide(int x, int y) { count++; if (y!=0) return (x/y)*count; else return 0; }
};

class A
{
    std::map< int, MEMFUNC > funcs;
public:
    A() { AddLocals(); }
    ~A() {}
    int …