小编ali*_*hoo的帖子

我有一个类,需要将12个参数传递给它的构造函数.所以我认为这个类的设计有问题.

我想询问是否有任何关于类设计的设计模式或一般规则集合,特别是它的构造函数.

我一直在阅读一篇关于MSDN中的无锁编程的文章.它说 :

在所有现代处理器上,您可以假设自然对齐的本机类型的读取和写入 是原子的.只要存储器总线至少与读取或写入的类型一样宽,CPU就会在单个总线事务中读取和写入这些类型,这使得其他线程无法在半完成状态下看到它们.

它给出了一些例子:

// This write is not atomic because it is not natively aligned.
DWORD* pData = (DWORD*)(pChar + 1);
*pData = 0;

// This is not atomic because it is three separate operations.
++g_globalCounter;

// This write is atomic.
g_alignedGlobal = 0;

// This read is atomic.
DWORD local = g_alignedGlobal;

我读了很多答案和评论说,没有什么能保证在C++中是原子的,甚至在标准中都没有提到,在SO中,现在我有点困惑.我误解了这篇文章吗？或者文章作者是否谈论了非标准和特定于MSVC++编译器的内容？

所以根据这篇文章,下面的作业必须是原子的,对吧？

struct Data
{
    char ID;
    char pad1[3];
    short Number;
    char pad2[2];
    char Name[5];
    char pad3[3];
    int Number2;
    double …

给定一个非连续的STL容器(您也可以考虑boost::unordered_map并boost::multi_index_container考虑),如果没有删除任何元素,是否保证容器内元素的内存地址永远不会改变(但是可以添加新的容器)？

例如

class ABC { };
//
//...
//
std::list<ABC> abclist;
ABC abc;
abclist.insert(abc);
ABC * abc_ptr = &(*abclist.begin());

在其他的字将abc_ptr被指出abc在整个执行,如果我不删除abc的abc_list.

我问这个是因为我要用ABCC++/Cli ABC包装类,所以我需要指向包装类中的实例的指针.ABC是一个简单的类,我希望容器处理内存.如果答案是否定的话我将使用std::list<ABC*>.

有什么区别:

new Thread(new ThreadStart(SomeFunc))

和:

new Thread( delegate() { SomeFunc();} )

此代码在我的计算机上提供奇怪的输出:

public class A
{
    int Num;

    public A(int num)
    {
        Num = num;
    }

    public void DoObj(object obj)
    {
        Console.Write(Num);
    }

    public void Do()
    {
        Console.Write(Num);
    }
}

/////// in void main()

for (int i = 0; i < 10; i++)
{
    (new Thread(new ThreadStart((new A(i)).Do))).Start(); // Line 1
    (new Thread(new ThreadStart(delegate() { (new A(i)).Do(); }))).Start(); // Line 2
    (new Thread(delegate() { (new A(i)).Do(); })).Start(); // Line 3 …

假设我有一个N个元素的向量,但是这个向量的n个元素都有有意义的数据.一个更新程序线程更新第n个或第n + 1个元素(然后设置n = n + 1),还检查n是否太接近N并在必要时调用vector :: resize(N + M).更新后,线程调用多个子线程来读取第n个数据并进行一些计算.

保证子线程永远不会更改或删除数据(实际上没有数据被删除),updater在完成更新后会调用它们.

到目前为止还没有出现任何问题,但是我想问一下,如果从前一个更新中留下一些子工作线程,在将向量重新分配给更大的内存块时是否会出现问题.
或者在这样的多线程情况下使用向量是否安全,因为它不是线程安全的？

编辑:由于只有当updater调用vector :: resize(N + M,0)时才进行插入,我的问题是否有任何可能的解决方案？由于STL向量的巨大性能,我不愿意用可锁定的向量替换它,或者在这种情况下是否有任何高性能,已知和无锁向量？

为什么输出这段代码:

#include <iostream>  
template<typename T> void f(T param) 
{ 
   std::cout << "General" << std::endl ; 
} 
template<> void f(int& param) 
{ 
   std::cout << "int&" << std::endl ; 
}  

int main() 
{   
  float x ;  f (x) ;   
  int y ; f (y) ;   
  int& z = y ; f (z) ; 
}  

是

一般
一般
一般

第三个是令人惊讶的,因为该功能完全专门用于 int&

编辑:我知道重载可能是一个合适的解决方案.我只想学习它背后的逻辑.

我编写了一小段关于动态加载程序集和从这些程序集创建类实例的代码,包括可执行文件,要动态加载的测试库和用于将动态程序集加载到新程序集的加载程序库Appdomain.Loader库由可执行文件和动态库引用.

//executable
[System.STAThreadAttribute()]
[System.LoaderOptimization(LoaderOptimization.MultiDomain)]
static void Main(string[] args)
{       
    AppDomainSetup domainSetup = new AppDomainSetup()
    {
        ApplicationBase = AppDomain.CurrentDomain.SetupInformation.ApplicationBase,
        ConfigurationFile = AppDomain.CurrentDomain.SetupInformation.ConfigurationFile,
        ApplicationName = AppDomain.CurrentDomain.SetupInformation.ApplicationName,
        LoaderOptimization = LoaderOptimization.MultiDomain
    };
    AppDomain childDomain = AppDomain.CreateDomain("MyDomain", null, domainSetup);
    Console.WriteLine(AppDomain.CurrentDomain.SetupInformation.LoaderOptimization.ToString());
    Console.WriteLine(childDomain.SetupInformation.LoaderOptimization.ToString());

    byte[] assembly = null;
    string assemblyName = "CSTestLib"; 

    using (FileStream fs = new FileStream(assemblyName+".dll",FileMode.Open))
    {
        byte[] byt = new byte[fs.Length];
        fs.Read(byt,0,(int)fs.Length);
        assembly = byt;          
    }

    object[] pararmeters = {assemblyName,assembly}; 
    string LoaderAssemblyName = typeof(AssemblyLoader).Assembly.FullName;
    string LoaderClassName = typeof(AssemblyLoader).FullName;
    AssemblyLoader assloader = (AssemblyLoader)childDomain.CreateInstanceAndUnwrap(LoaderAssemblyName,LoaderClassName , …

我只是在玩弄了解智能指针并尝试制作我的但我遇到的情况我并不完全理解.这是代码:

#include <iostream>
template <class T>
class Holder
{
private:
        T * obj;
public:
        Holder(T * tt) : obj(tt) 
        {
                std::cout << "ctor : " << tt->dummy << std::endl;
        }
        T * operator -> ()
        {
                return obj;
        }
        operator bool()
        {
                return obj;
        }
        T * const get() const
        {
                return obj;
        }
        void reset() {swap(0);}
        void swap(T * other)
        {
                obj = other;
        }
        Holder & operator = (const Holder& holder)
        {
                obj = holder.get();
                return *this;
        } …

在我的申请中,我有3个主要部分:

• Exe:可执行文件
• Lib_A:一个库包含一个单例类和一个基类,用于在单例类中使用的一些计算
• Lib_B:库包含从Lib_A中的基础派生的许多类

我在Lib_B中有派生类的原因是,我想在运行时从Exe编译Lib_B.我需要在计算过程中生成派生类而不终止整个系统.这对我来说太重要了.这意味着最初我可能会说Lib_B1是动态加载的,我也可以将其他版本的Lib_B编译为Lib_B2,Lib_B3,Lib_B4等,并动态加载它们.所有Lib_Bx库都有入口点函数来导出它们中的类.

因此,请考虑以下事实:

• 在运行时,将有各种数量的文件共享相同的Lib_A.
• 该应用程序必须在Windows和Linux中运行.因此,部分跨平台性是一个问题.
• 我将使用一些库,如TBB,Boost,Qt,它们可能有自己的库,如tbb.dll等.

Lib_A与Exe和Lib_Bx的静态或动态链接有哪些优缺点？如何影响性能,系统大小等？除了我需要为Exe,Lib_A和Lib_Bx使用相同编译器的每个OS之外,是否还有任何危险或困难的情况.

整个系统的设计对我来说是一个非常难的问题,所以任何评论都将受到赞赏.

非常感谢.

我正在尝试实现一个大型对象缓存(最多500000),并且需要能够以两种不同的方式访问它们......

每个项目的关键由三个不同的字符串组成; ItemNumber,PubCode和SizeCode.在某些情况下,我将调用所有这三个值的匹配来返回单个对象.在其他情况下,我将仅在ItemNumber和PubCode上调用匹配,以便返回一组对象.

什么是最好的收藏品？

我考虑过只使用一个通用的对象列表(其中所有三个键值都是属性)并使用LINQ来查询它,但是我不相信这将是最有效的方法当你考虑集合的大小.

任何帮助将一如既往地受到赞赏!