小编Mar*_* Ba的帖子

在Windows-125*代码页中(实际上,在相应ISO*的代码页中),某些字符代码没有定义相应的字符.留下一些没有角色的字符代码背后的前提是什么？

我对这个问题的理解是:如果基于7位的代码页不够,并且必须发明多个8位代码页,那么那些8位代码页(从之前的经验中学习)应该具有尽可能多的字符.它是可能的,而实际上一些字符代码缺乏一个字符.

又名.如何防止const&参数意外绑定到临时？

我们有一个基本上看起来像这样的类:

template<typename T>
struct Observer {
  const T* target;

  void observe(const T& x) {
     target = &x;
  }
};

也就是说,这些对象将"保持"它们传递的const-ref.

我们有一个错误,其中observe函数意外地传递了一个临时对象 - 这种情况永远不会有效.

我们有什么选择来防止意外绑定到临时？

更改签名(const T* px)将在技术上起作用(取一个临时的地址是编译器警告=错误)这不是很有吸引力的其他原因.

_{附注:是的,这将始终有潜在生命周期管理问题,但到目前为止,真实的东西工作,因为其有限的使用模式非常好-但传递的临时意外已经在实践中被观察到,所以我们想可能解决,第一.}

我目前正在尝试决定是否“结构化”相当长的参数集：

void fooCopy1(std::string const& source, std::string const& destination, std::string const& filter, std::string const& temp);

对此：

struct FooCopyArgs {
    std::string source;
    std::string destination;
    std::string filter;
    std::string temp;
};
void fooCopy2(FooCopyArgs const& args);

正如在另外两个问题中已经回答的那样：

• C++ 使用函数的结构参数而不是多个参数？
• 为什么将结构传递给函数而不是单独的参数？

重构它可能有几个可读性/可维护性的优点。对于其中的一些问题，请参阅链接的问题。

但总的来说，我在 C++ 中看到了这种方法的一个“大”问题，那就是在调用此函数之前始终必须复制字符串，而不是使用const&参数。

这将违反C++ 核心指南 F.16 “按值传递廉价复制类型，并通过引用 const 传递其他类型”。

也就是说，通常由 传递的非廉价只读参数const ref需要复制到结构中，这将是一种普遍的悲观化。

（是的，结构本身将通过 const ref 传递，但需要首先复制结构数据成员。）

例子：

const string temp = ...;
const string filter = ...;
...
fooCopy2({"sourceItem", "targetItem", filter, temp});

对于 …

我知道没有"正确"的堆大小,但你在应用程序(应用程序类型,jdk,os)中使用哪个堆大小？

JVM选项-Xms(初始/最小)和-Xmx(最大)允许控制堆大小.什么设置在哪种情况下有意义？什么时候默认适当？

我们有一个测量数据处理应用程序,目前所有数据都保存为C++ float,这意味着我们的x86/Windows平台上有32bit/4byte.(32位Windows应用程序).

由于精度正在成为一个问题,因此一直在讨论转向另一种数据类型.目前讨论的选项是切换到double(8byte)或在__int64(8byte)之上实现固定的十进制类型.

__int64甚至讨论使用固定十进制解决方案作为基础类型的原因是有人声称double性能(仍)明显比处理floats 差,并且我们可能会看到使用本机整数类型存储数字的显着性能优势.(请注意,我们确实可以使用固定的小数精度,尽管代码显然会变得更复杂.)

显然我们最终需要进行基准测试,但我想问一下,加倍的声明是否会让现代处理器看到真相？我想对于大型阵列双打可能会使缓存命中更加浮动,但是否则我真的看不出它们在性能方面会有什么不同？

当加载DLL(动态地或LoadLibrary/ Ex或静态地)时,是否有可能阻止Windows使用PATH环境变量来查找要加载的DLL依赖的DLL /其他DLL？

我可以为动态链接库搜索顺序找到的文档似乎意味着没有办法阻止搜索PATH,但也许我错过了什么？

我问这个的原因是我们希望有一个快速失败的方案,当应用程序文件夹中缺少(静态)链接的DLL但可能在PATH上存在(不同版本).

如果Windows上有可执行文件,则可以使用DUMPBIN实用程序查看其导入部分(例如,包含在Visual Studio中).

要获取所有导入的DLL的列表,您可以运行类似这样的东西(只是一个任意的例子):

C:\Programme\GIMP-2.0\bin>dumpbin /IMPORTS gimp-2.4.exe | grep -i \.dll
    libgimpcolor-2.0-0.dll
    libgimpmath-2.0-0.dll
    libgimpmodule-2.0-0.dll
    libgimpthumb-2.0-0.dll
    libgimpwidgets-2.0-0.dll
    libart_lgpl_2-2.dll
    libfontconfig-1.dll
    freetype6.dll
    libgdk-win32-2.0-0.dll
    libgdk_pixbuf-2.0-0.dll
    libglib-2.0-0.dll
    libgobject-2.0-0.dll
    libgthread-2.0-0.dll
    libgtk-win32-2.0-0.dll
    intl.dll
    libpango-1.0-0.dll
    libpangoft2-1.0-0.dll
    libgimpbase-2.0-0.dll
    libgimpconfig-2.0-0.dll
    KERNEL32.dll
    msvcrt.dll
    msvcrt.dll
    USER32.dll

我现在推测另一个问题,对于独立的DLL,Loader(将DLL映射到地址空间并调用它们的DllMain函数的组件)将按照它们在导入部分中出现的顺序加载DLL.

注意:这显然只适用于独立的DLL,因为加载器必须解析依赖关系,因此依赖于任何其他DLL的任何DLL将始终是加载器.所以这个问题只适用于独立(非系统)DLL.

为了坚持我的(任意选择)上面的例子,

C:\Programme\GIMP-2.0\bin>dumpbin /IMPORTS libgimpcolor-2.0-0.dll | grep -i \.dll
Dump of file libgimpcolor-2.0-0.dll
    libglib-2.0-0.dll
    libgobject-2.0-0.dll
    msvcrt.dll

C:\Programme\GIMP-2.0\bin>dumpbin /IMPORTS libgimpmath-2.0-0.dll | grep -i \.dll
Dump of file libgimpmath-2.0-0.dll
    libglib-2.0-0.dll
    libgobject-2.0-0.dll
    msvcrt.dll

C:\Programme\GIMP-2.0\bin>dumpbin /IMPORTS libgobject-2.0-0.dll | grep -i \.dll
Dump of …

我知道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;
}

何时何地我应该使用全局对象？全局对象是否有特定用途？请帮我.

给定C++模板类(或函数)定义:

template<typename T>
struct Foo {
  T member;
};

- 如果在一个更复杂的情况下我想让typename更具表现力,那么接受或避免使用哪种命名约定(以及为什么).例子:

template<typename MORE_EXPRESSIVE_NAME>
struct More {
  MORE_EXPRESSIVE_NAME* p_;
  More(MORE_EXPRESSIVE_NAME* p);
  ...
};

template<typename MORE_EXPRESSIVE_NAME>
More<MORE_EXPRESSIVE_NAME>::More(MORE_EXPRESSIVE_NAME* p)
: p_(p)
{ }

要么

template<typename MoreExpressiveName>
struct More {
  MoreExpressiveName* p_;
  More(MoreExpressiveName* p);
  ...
};

template<typename MoreExpressiveName>
More<MORE_EXPRESSIVE_NAME>::More(MoreExpressiveName* p)
: p_(p)
{ }

要么

template<typename mr_exprs_nm>
struct More {
  mr_exprs_nm* p_;
  More(mr_exprs_nm* p);
  ...
};

template<typename mr_exprs_nm>
More<mr_exprs_nm>::More(mr_exprs_nm* p)
: p_(p)
{ }

普通指针地址和指针"地址"有什么区别？

#include<iostream>

using namespace std;

int main()
{
    int * a= new int[1];
    cout<<a<<endl;
    cout<<&a<<endl;
    return 0;
}

这打印出两个不同的值:

0x8b1a438
0xffbb6b8c