标签: shared

如何在同一Linux程序中同时使用C++共享库和静态库？

使用g ++进行管理时,我试图-static在库之前和之后安排命令,我不想静态链接,但没有结果.ld通过g++抱怨共享库的.a文件在哪里(找不到 -无错误).

编辑:问题不是找不到 - 无论什么错误,因为它只是发生因为没有指定库的静态版本.我要做的是指定哪些库是静态链接的,哪些是动态的.

我遇到了OpenMP和共享变量的问题我无法理解.我所做的一切都在Fortran 90/95中.

这是我的问题:我的main程序中定义了一个并行区域,带有子句DEFAULT(SHARED),我在其中调用了一个执行某些计算的子程序.我有一个我分配的局部变量(数组),我在其上进行计算.我期待这个数组被共享(因为该DEFAULT(SHARED)子句),但似乎并非如此.

这是我正在尝试做的一个例子,它重现了我得到的错误:

program main
  !$ use OMP_LIB
  implicit none

  integer, parameter :: nx=10, ny=10
  real(8), dimension(:,:), allocatable :: array

  !$OMP PARALLEL DEFAULT(SHARED)
  !$OMP SINGLE
  allocate(array(nx,ny))
  !$OMP END SINGLE

  !$OMP WORKSHARE
  array = 1.
  !$OMP END WORKSHARE

  call compute(array,nx,ny)

  !$OMP SINGLE
  deallocate(array)
  !$OMP END SINGLE
  !$OMP END PARALLEL

contains
  !=============================================================================
  ! SUBROUTINES
  !=============================================================================
  subroutine compute(array, nx, ny)
    !$ use OMP_LIB
    implicit none

    real(8), dimension(nx,ny) :: array
    integer :: nx, ny
    real(8), dimension(:,:), allocatable …

我有一个多用户Delphi程序,需要通过网络共享文件夹来存储数据.我希望程序更改该文件夹中的文件,但不是普通用户(可以看到此文件夹)或网络病毒...

我想用密码保护这个文件夹(Windows 7),但我需要通过我的程序编写新文件或编辑现有文件,我不知道如何做到这一点.

简而言之,我需要通过这样的代码连接和断开共享文件夹

ConnectToFolder(\\myServerMachine\mySharedfolder username:me password:myPassword);
disConnectToFolder(\\myServerMachine\mySharedfolder username:me password:myPassword);

这可能吗？

我正在制作一个单身课程供我使用.我见过单例类的代码是这样的:

//First Example

+ (id)sharedManager {
    static MyManager *sharedMyManager = nil;
    static dispatch_once_t onceToken;
    dispatch_once(&onceToken, ^{
        sharedMyManager = [[self alloc] init];
     });
    return sharedMyManager;
 }


 //Second Example

static SingletonSample *sharedObject;

+ (SingletonSample*)sharedInstance {
    if (sharedObject == nil) {
        sharedObject = [[super allocWithZone:NULL] init];
    }
    return sharedObject;
}

秒似乎很好,可以理解.但我很困惑在第一个例子中,每次将sharedMyManager设置为nil并且每次都有一个共享管理器的分配,我怀疑的是第一个例子将如何返回类的相同引用(Singleton).

谢谢.

我正在创建一个C++共享库,它链接到一些Boost库(本地机器上的Boost版本1.55).

我可以在我的机器上使用我的库,但由于未定义的引用,我无法在具有不同版本的Boost的另一个系统上使用它(假设为1.54).

我在使用CMake,这里是CMakeLists.txt文件:

cmake_minimum_required(VERSION 2.8)
project(my_library)

set(CMAKE_BUILD_TYPE Release)
set(CMAKE_LIBRARY_OUTPUT_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/lib)

include_directories(${CMAKE_CURRENT_SOURCE_DIR}/include)

FILE(GLOB_RECURSE INCLUDE_FILES "include/*.hpp")
FILE(GLOB_RECURSE SOURCE_FILES "src/*.cpp")

add_library(${PROJECT_NAME} SHARED ${INCLUDE_FILES} ${SOURCE_FILES})

target_link_libraries(${PROJECT_NAME} -pthread -lboost_filesystem -lboost_regex -lboost_system)

我是图书馆创作的新手,我在这个问题上挣扎了好几天.我想知道我是否必须使用Boost创建一个静态库.但我希望我的图书馆尽可能小.

编辑:当我检查我的lib依赖项时,我得到了Boost正则表达式: libboost_regex.so.1.55.0 => /usr/lib/x86_64-linux-gnu/libboost_regex.so.1.55.0 (0x00007fe228a27000)

是否可以更新此链接以针对特定版本的Boost进行链接？

有什么区别：

@Shared
MyObject myObject = new MyObject()

和

MyObject myObject

def setupSpec() {
    myObject = new MyObjec()
}

为什么要在第二个示例中使用 @Shared 注释？两者都只创建一次，不是吗？

我试图在另一个实体组件中显示一个实体组件。

我在网上找到了一些有关共享模块的信息，我也检查了这篇文章，但它仍然不适合我。

我想在共享首选项中保存从 DateTime-picker 中选取的日期，以便在重新启动应用程序后也会显示

child: InkWell(
                      onTap: (){
                        DatePicker.showDateTimePicker(context,
                        showTitleActions: true,
                        minTime: DateTime.now().toLocal(),
                        onConfirm: (date){
                          setState(() {
                            _dateTime = date;

                          });
                        },
                        currentTime: DateTime.now().toLocal(),
                        locale: LocaleType.de
                        );
                      },
                      child: Text(
                        (_dateTime == null ? 'Wählen sie Ihren nächsten Termin' : DateFormat("dd-MM-yyyy hh:mm").format(_dateTime)),
                        style: TextStyle(
                          fontSize: data.size.height / 29,
                          color: Colors.grey[400],
                        ),
                      ),
                    ),

I came across an elegant line of reading a binary file into a vector like this (that works):

        std::ifstream ifs("myfile.bin", std::ios::binary);
        std::vector<char> buffer(std::istreambuf_iterator<char>(ifs), {});

Instead since I want my vector to be a shared pointer I write:

        std::ifstream ifs("myfile.bin", std::ios::binary);
        auto sp = std::make_shared<std::vector<char>>(std::istreambuf_iterator<char>(ifs), {});

I.e just pass the vector constructor arguments to make_shared (as I usually do to create any shared pointer of any objects). But I get: error: no matching function for call to 'make_shared'?

Detailed output:

/usr/include/c++/11.1.0/bits/shared_ptr.h|873 …

对于编写一个非常大的程序，我认为没有办法减轻必须为每个使用某种共享行为的结构编写相同的代码。

例如，Dog 可能会“吠叫”：

struct Dog {
    is_barking: bool,
    ....
}
impl Dog {
    pub fn bark(self) {
        self.is_barking = true;
        emit_sound("b");
        emit_sound("a");
        emit_sound("r");
        emit_sound("k");
        self.is_barking = false;
    }
    ....
}

这种狗的许多品种可能存在：

struct Poodle {
    unique_poodle_val: &str
}
impl Poodle {
    pub fn unique_behaviour(self) {
        self.some_behaviour();
    }
}

struct Rottweiler {
    unique_rottweiler_val: u32
}
impl Rottweiler{
    pub fn unique_behaviour(self) {
        self.some_behaviour();
    }
}

问题是，以我目前的知识来看，Rust 似乎无法做到这一点，但它需要完成，我需要一个解决方法：

1. 允许贵宾犬和罗威纳犬使用该品种不需要考虑的完全相同的行为吠叫。
2. 无需在每个品种模块中重新编码 bark() 就可以实现这一点，这是编程地狱，因为它会导致重复的代码，并且每个模块都必须实现 bark()。
3. Traits 是相反的，不能访问结构体，因此 default-trait 实现不起作用。Rust 不支持类似 OOP 的继承，这里也不需要它。

因此，我问：既然贵宾犬和罗威纳犬的吠叫方式完全相同，那么如何在不重写每个模块中的 bark() 的情况下实现 bark() …