全部问题(coding)

我正在学习 SOLID 原则。在学习“依赖倒置原则”时发现类应该依赖于接口而不是具体类。

这是否意味着不允许组合？另外，聚合是否与 DIP 相同？

作品：

    class HPDesktop {
        private BluetoothMouse bluetoothMouse;
        private BluetoothKeyboard bluetoothKeyboard;
    
        public HPDesktop(){
            bluetoothMouse = new BluetoothMouse();
            bluetoothKeyboard = new BluetoothKeyboard();
        } 
     }

DIP：（这似乎是一种聚合）

class HPDesktop {
    private Mouse mouse;
    private Keyboard keyboard;

    public HPDesktop(Mouse mouse, Keyboard keyboard){
        this.mouse = mouse;
        this.keyboard = keyboard;
    }
}

我正在阅读 GNU/GCC 的文档，然后我停在了 的描述处__attribute__ ((packed))。它说：

已打包

packed 属性指定变量或结构字段应具有最小可能的对齐方式 - 每个变量一个字节，每个字段一位，除非您使用 aligned 属性指定更大的值。

这是一个结构体，其中字段 x 被打包，因此它紧跟在 a 之后：

struct foo
{
    char a;
    int x[2] __attribute__ ((packed));
};

我想知道这个属性究竟如何工作，以及此代码是否：

struct bar
{
    char a:1 __attribute__ ((packed));
};

将创建 1 位结构而不是 1 字节。

该应用程序仍然只显示空白屏幕。这是我的主要应用程序代码：

import 'package:flutter/material.dart';
import 'package:firebase_core/firebase_core.dart';

void main() async {
  await Firebase.initializeApp();
  runApp(MyApp());
}

class MyApp extends StatelessWidget {
  @override
  Widget build(BuildContext context) {
    return MaterialApp(
      home: Scaffold(
        appBar: AppBar(title: Text('Firebase Integration')),
        body: Center(child: Text('Hello, Firebase!')),
      ),
    );
  }
}

任何帮助或建议都将不胜感激！

在没有继承的类中，我预计该virtual关键字不会产生明显的影响。但是，在下面的代码示例中，添加它会破坏编译。我想了解背后的机制。为什么该virtual关键字会破坏编译？

没有 virtual 关键字它编译得很好。

#define USE_VIRTUAL 1
// compile with: cl /W4 /EHsc main.cpp /link /out:main.exe
#include<iostream>
#include<memory>

struct Dummy {int i = 3;};
class Uncopyable {
    public:
        // Implicitly delete the copy constructor by having
        // a non-copyable member.
        std::unique_ptr<Dummy> m_innerPtr;

        // A virtual destructor to allow correct inheritance.
        // I first thought that this implicitly deletes the 
        // copy-assignment and copy-constructor, 
        // but it does not. It does, however, implicitly
        // delete the move constructor and assignment.
        virtual ~Uncopyable() = default;

        // accessible constructor
        Uncopyable() = default;
        Uncopyable(std::unique_ptr<Dummy> dummy):m_innerPtr(std::move(dummy)){};

};


template <typename MaybeCopyable>
class Bamboozle {
    public: 
    void foo(std::shared_ptr<MaybeCopyable> obj) {
        std::cout << "Reached Bamboozle::foo(shared_ptr)" << std::endl;
    }

    // overload that takes an object by value
#if USE_VIRTUAL
    virtual
#endif
    void foo(MaybeCopyable obj){
        std::cout << "Reached Bamboozle::foo(Uncopyable)" << std::endl;
        foo(std::make_shared<Uncopyable>(std::move(obj)));
    }
};



int main(int argc, char** argv){
    // construct param objects
    std::shared_ptr<Uncopyable> uncSharedPtr = std::make_shared<Uncopyable>();

    // prints Bamboozle::foo(shared_ptr)
    Bamboozle<Uncopyable> bamboozleObj;
    bamboozleObj.foo(uncSharedPtr);
    return 0;
};

如果您想了解我认为与此有关的其他方面，请参阅此问题（由于太详细而关闭）以了解更多背景信息。特别是模板和移动构造函数。类模板是重现此行为所必需的。

错误消息是：

cl /W4 /EHsc main.cpp /link /out:main.exe
Microsoft (R) C/C++ Optimizing Compiler Version 19.38.33134 for x64
Copyright (C) Microsoft Corporation.  All rights reserved.

main.cpp
main.cpp(46): warning C4100: 'argv': unreferenced formal parameter
main.cpp(46): warning C4100: 'argc': unreferenced formal parameter
C:\Program Files\Microsoft Visual Studio\2022\Community\VC\Tools\MSVC\14.38.33130\include\xutility(255): error C2280: 'Uncopyable::Uncopyable(const Uncopyable &)': attempting to reference a deleted function
main.cpp(24): note: compiler has generated 'Uncopyable::Uncopyable' here
main.cpp(24): note: 'Uncopyable::Uncopyable(const Uncopyable &)': function was implicitly deleted because a data member invokes a deleted or inaccessible function 'std::unique_ptr<Dummy,std::default_delete<Dummy>>::unique_ptr(const std::unique_ptr<Dummy,std::default_delete<Dummy>> &)'
C:\Program Files\Microsoft Visual Studio\2022\Community\VC\Tools\MSVC\14.38.33130\include\memory(3319): note: 'std::unique_ptr<Dummy,std::default_delete<Dummy>>::unique_ptr(const std::unique_ptr<Dummy,std::default_delete<Dummy>> &)': function was explicitly deleted
C:\Program Files\Microsoft Visual Studio\2022\Community\VC\Tools\MSVC\14.38.33130\include\xutility(255): note: the template instantiation context (the oldest one first) is
main.cpp(51): note: see reference to class template instantiation 'Bamboozle<Uncopyable>' being compiled
main.cpp(38): note: while compiling class template member function 'void Bamboozle<Uncopyable>::foo(MaybeCopyable)'
        with
        [
            MaybeCopyable=Uncopyable
        ]
main.cpp(40): note: see reference to function template instantiation 'std::shared_ptr<Uncopyable> std::make_shared<Uncopyable,Uncopyable>(Uncopyable &&)' being compiled
C:\Program Files\Microsoft Visual Studio\2022\Community\VC\Tools\MSVC\14.38.33130\include\memory(2769): note: see reference to function template instantiation 'std::_Ref_count_obj2<_Ty>::_Ref_count_obj2<_Ty>(_Ty &&)' being compiled
        with
        [
            _Ty=Uncopyable
        ]
C:\Program Files\Microsoft Visual Studio\2022\Community\VC\Tools\MSVC\14.38.33130\include\memory(2094): note: see reference to function template instantiation 'void std::_Construct_in_place<_Ty,_Ty>(_Ty &,_Ty &&) noexcept(false)' being compiled
        with
        [
            _Ty=Uncopyable
        ]

我希望当蓝色 div 中没有太多内容时，蓝色 div 缩小并允许绿色 div 占用更多空间，反之亦然。但是，如果两个 div 中都有大量内容，则两个 div 都不能大于容器的 50%。

.container {
  display: flex;
  flex-direction: column;
  height: 300px;
}

.topDiv {
  background-color: blue;
  color: white;
  flex: 1;
  overflow: auto;
}

.bottomDiv {
  background-color: green;
  color: white;
  flex: 1;
  overflow: auto;
}

<div class="container">
    <div class="topDiv">
      <p>Lorem ipsum dolor sit amet, consectetur adipisicing elit. Minus eius quia a iure, odit corporis, iusto molestiae delectus dolores possimus accusantium voluptatum, nam. Unde atque veritatis quo at, in eligendi.</p>
    </div>
    <div class="bottomDiv">
      <p>Lorem ipsum dolor sit amet, consectetur adipisicing elit. Minus eius quia a iure, odit corporis, iusto molestiae delectus dolores possimus accusantium voluptatum, nam. Unde atque veritatis quo at, in eligendi.</p>
      <p>Lorem ipsum dolor sit amet, consectetur adipisicing elit. Minus eius quia a iure, odit corporis, iusto molestiae delectus dolores possimus accusantium voluptatum, nam. Unde atque veritatis quo at, in eligendi.</p>
      <p>Lorem ipsum dolor sit amet, consectetur adipisicing elit. Minus eius quia a iure, odit corporis, iusto molestiae delectus dolores possimus accusantium voluptatum, nam. Unde atque veritatis quo at, in eligendi.</p>
      <p>Lorem ipsum dolor sit amet, consectetur adipisicing elit. Minus eius quia a iure, odit corporis, iusto molestiae delectus dolores possimus accusantium voluptatum, nam. Unde atque veritatis quo at, in eligendi.</p>
      <p>Lorem ipsum dolor sit amet, consectetur adipisicing elit. Minus eius quia a iure, odit corporis, iusto molestiae delectus dolores possimus accusantium voluptatum, nam. Unde atque veritatis quo at, in eligendi.</p>
      <p>Lorem ipsum dolor sit amet, consectetur adipisicing elit. Minus eius quia a iure, odit corporis, iusto molestiae delectus dolores possimus accusantium voluptatum, nam. Unde atque veritatis quo at, in eligendi.</p>
      <p>Lorem ipsum dolor sit amet, consectetur adipisicing elit. Minus eius quia a iure, odit corporis, iusto molestiae delectus dolores possimus accusantium voluptatum, nam. Unde atque veritatis quo at, in eligendi.</p>
      <p>Lorem ipsum dolor sit amet, consectetur adipisicing elit. Minus eius quia a iure, odit corporis, iusto molestiae delectus dolores possimus accusantium voluptatum, nam. Unde atque veritatis quo at, in eligendi.</p>
      <p>Lorem ipsum dolor sit amet, consectetur adipisicing elit. Minus eius quia a iure, odit corporis, iusto molestiae delectus dolores possimus accusantium voluptatum, nam. Unde atque veritatis quo at, in eligendi.</p>
    </div>
  </div>

下面是 SystemTimeToTzSpecificLocalTime 的函数原型：

BOOL SystemTimeToTzSpecificLocalTime(
  [in, optional] const TIME_ZONE_INFORMATION *lpTimeZoneInformation,
  [in]           const SYSTEMTIME            *lpUniversalTime,
  [out]          LPSYSTEMTIME                lpLocalTime
);

正如您所看到的，第二个和第三个参数都是指向 SYSTEMTIME 结构的指针，因此至少从静态类型检查的角度来看，应该可以为这两个参数传递相同的指针。

然而，该文档没有说明这样做是否安全。

在我的测试中，我发现为两个参数传递相同的指针确实可以按预期工作。该函数确实修改了 SYSTEMTIME 结构，并且输出是正确的。

这是一个简单的例子：

#include <windows.h>
void main() {
    SYSTEMTIME tm;
    GetSystemTime(&tm);
    SystemTimeToTzSpecificLocalTime(NULL, &tm, &tm);
    wprintf(L"Local Time: %02d:%02d:%02d\n", tm.wHour, tm.wMinute, tm.wSecond);
}

我的问题是：为两个参数传递相同的指针是否安全？或者我应该使用新的 SYSTEMTIME 结构来输出？

我在文档中找不到有关此内容的任何信息。 ( https://learn.microsoft.com/en-us/windows/win32/api/timezoneapi/nf-timezoneapi-systemtimetotzspecificiallocaltime )

谢谢！

lambda 表达式中的参数（通过值捕获）的有效期限是多长？该参数在 lambda 本身的生命周期内有效，还是仅在调用期间有效？

例如：

[value = 5] { DoSomething(&value) }

&valuelambda 调用完成后指针是否仍然有效？（当然假设 lambda 本身还活着。）

我见过这个类似名称的问题，但这涉及修改表达式内的lambda ，而不是生命周期。

为了回答这些评论，我还怀疑value被捕获为成员（因此应该在表达式之外保持活动状态）。但我担心这可能是错误的，因为value理论上可以捕获为成员，然后按值传递到表达式本身（因此我们看到的引用不会保持活动状态）。

我有 UTF-8 字符串，我想搜索所有出现的img_(\d+). 我试过原版的

$pattern = '/img_(\d+)/u';
preg_match_all($pattern, $text, $matches, PREG_OFFSET_CAPTURE);

但它给了我错误的模式偏移。

我也尝试过：

mb_internal_encoding('UTF-8');
$pattern = 'img_(\d+)';
mb_ereg_search_init($content, $pattern);

$matches = [];        
while ($result = mb_ereg_search_regs()) {
    $matches[] = [
        'match' => $result[0],
        'offset' => mb_ereg_search_getpos() - mb_strlen($result[0]),
    ];
}

但它给了我与 相同的结果preg_match_all。

但是，当我使用以下命令手动运行搜索时：

$pos = mb_strpos($content, "img_1", 0);

我得到了正确的偏移量。

示例代码：

$str = "příliš žluťoučký img_1 kůn úpěl ďábelské ódy";

$pattern = '/img_(\d+)/u';
preg_match_all($pattern, $str, $matches, PREG_OFFSET_CAPTURE);

print_r($matches); //gives 24 (wrong)

echo mb_strpos($str, "img_1", 0); //gives 17 (correct)

如何解决这个问题？

考虑以下简单示例：

use std::cell::RefCell;

// Compiles fine
fn good(t: RefCell<String>) -> bool {
    t.borrow().len() == 12
}

// error[E0597]: `t` does not live long enough
fn bad(t: RefCell<String>) -> bool {
    let t = t;
    t.borrow().len() == 12
}

操场

该bad函数无法编译并出现以下错误：

error[E0597]: `t` does not live long enough
  --> src/lib.rs:9:5
   |
8  |     let t = t;
   |         - binding `t` declared here
9  |     t.borrow().len() == 12
   |     ^---------
   |     |
   |     borrowed value does not live long enough
   |     a temporary with access to the borrow is created here ...
10 | }
   | -
   | |
   | `t` dropped here while still borrowed
   | ... and the borrow might be used here, when that temporary is dropped and runs the destructor for type `Ref<'_, String>`
   |
   = note: the temporary is part of an expression at the end of a block;
           consider forcing this temporary to be dropped sooner, before the block's local variables are dropped
help: for example, you could save the expression's value in a new local variable `x` and then make `x` be the expression at the end of the block
   |
9  |     let x = t.borrow().len() == 12; x
   |     +++++++                       +++

这对我来说看起来非常奇怪。仅将函数参数重新分配给局部变量会导致编译失败。你能解释一下为什么吗？

在 JavaFX 中，FXMLLoader使用 0-arg 构造函数在 .fxml 文件中自动创建指定的控制器。FXMLLoader#setController它还提供了使用或手动设置/创建控制器的方法FXMLoader#setControllerFactory。

我现在的问题是它们之间有什么区别？是否存在一种情况比另一种更好？

这两种方法的文档并没有真正回答我的问题。