Slava's questions

Então eu tenho esse trecho aqui que envolve um bloco:

NSArray<Class> *acceptableClasses = @[[DesktopEntity class]];
    __block NSInteger insertIdx = row;
    
    
    [info enumerateDraggingItemsWithOptions:0 forView:_tableView classes:acceptableClasses searchOptions:nil usingBlock:^(NSDraggingItem *draggingItem, NSInteger idx, BOOL *stop)
     {
        
        
        DesktopEntity *entity = draggingItem.item;
        
       
        [_tableContents insertObject:entity atIndex: insertIdx];
        [_tableView insertRowsAtIndexes:[NSIndexSet indexSetWithIndex:insertIdx] withAnimation:NSTableViewAnimationEffectGap];
        
    
        draggingItem.draggingFrame = [_tableView frameOfCellAtColumn:0 row: insertIdx];
        ++insertIdx;
    }];

compila bem, mas estou recebendo um aviso:

O bloco retém implicitamente 'self'; menciona explicitamente 'self' para indicar que este é o comportamento pretendido

Estou com alguma dificuldade para entender o que isso significa . Consegui fazer o aviso desaparecer apenas digitando a palavra-chave self antes das variáveis:

[self.tableContents insertObject:entity atIndex: insertIdx];
[self.tableView insertRowsAtIndexes:[NSIndexSet indexSetWithIndex:insertIdx] withAnimation:NSTableViewAnimationEffectGap];


draggingItem.draggingFrame = [self.tableView frameOfCellAtColumn:0 row: insertIdx];
++insertIdx;

Mas também vi pessoas usando construções como

__weak typeof(self) weakSelf = self;

e então usar esse 'weakSelf' em vez disso, qual é a diferença aqui e minha primeira abordagem está errada?

Preciso criar alguns curingas para corresponder a certas instruções.

Por exemplo, em x86, para corresponder à maioria das instruções CALL, o seguinte padrão será suficiente:

E8 ?? ?? ?? ??

onde E8 é o opcode e os 4 bytes seguintes são o endereço relativo para o qual saltar.

Mas os opcodes para arm64, especificamente o conjunto de instruções A64, parecem ser muito mais confusos, tipo, eu tenho estas duas instruções:

0A696938               ldrb       w10, [x8, x9] ; 
EB834039               ldrb       w11, [sp, #0xc0 + var_A0]

Não há nenhuma relação óbvia se você apenas olhar as codificações 0A696938 e EB834039 . Como obtenho o opcode desta instrução ldrb para criar um padrão como o do x86?

Parece que os opcodes não ocupam um byte inteiro como no x86

Eu tenho uma janela básica baseada em diálogo herdada de CDialogImpl em WTL:

class CMainDlg : public CDialogImpl<CMainDlg>
{
public:
    enum { IDD = IDD_MAINDLG };
    
    BEGIN_MSG_MAP_EX(CMainDlg)
        MESSAGE_HANDLER(WM_INITDIALOG, OnInitDialog)
        COMMAND_ID_HANDLER(ID_APP_ABOUT, OnAppAbout)
        COMMAND_ID_HANDLER(IDOK, OnOK)
        COMMAND_ID_HANDLER(IDCANCEL, OnCancel)
    END_MSG_MAP()

    LRESULT OnInitDialog(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/, BOOL& /*bHandled*/);
    LRESULT OnAppAbout(WORD /*wNotifyCode*/, WORD /*wID*/, HWND /*hWndCtl*/, BOOL& /*bHandled*/);
    LRESULT OnOK(WORD /*wNotifyCode*/, WORD wID, HWND /*hWndCtl*/, BOOL& /*bHandled*/);
    LRESULT OnCancel(WORD /*wNotifyCode*/, WORD wID, HWND /*hWndCtl*/, BOOL& /*bHandled*/);


protected:
    CListViewCtrl wndList1;

}

Ao inicializar a caixa de diálogo no OnInitDialog, tento preencher esta visualização de lista que criei no editor de recursos e a nomeei IDC_LIST :

LRESULT CMainDlg::OnInitDialog(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/, BOOL& /*bHandled*/)
{
    // center the dialog on the screen
    CenterWindow();

    // attach via CWindow ( CListViewCtrl )
    //HWND hwndList = GetDlgItem( IDC_LIST );
    wndList1.Attach( GetDlgItem( IDC_LIST ) );
    
    wndList1.InsertColumn( 0,  "Column1" , LVCFMT_LEFT, 120, 0 );


    return TRUE;
}

Mas mesmo após a chamada para InsertColumn não vejo nenhuma coluna, tentei outras sobrecargas para esta função que exigem a criação de um LVCOLUMNA , mas também não funcionou. Por que isso está acontecendo?

Portanto, tenho dois vetores classificados e queria mesclá-los em um único vetor classificado sem usar um vetor adicional.

Como existe essa condição, não posso usar std::merge , então tentei std::inplace_merge .

Eu tenho esta função que leva ambos os vetores e dois números m e n que são o número de elementos em cada vetor. Veja como resolvi esse problema:

void merge(vector<int>& nums1, int m, vector<int>& nums2, int n) 
    {
         auto it = std::remove_if(std::execution::par, nums1.begin() + m, nums1.end(), 
             [](const int val)
             {
                 return val == 0;
             }
         );
         nums1.erase(it, nums1.end());

        nums1.insert(nums1.end(), nums2.begin(), nums2.end());
        std::inplace_merge(std::execution::par, nums1.begin(), nums1.begin() + nums1.size() - nums2.size(), nums1.end());
    }

Caso de exemplo

vec 1 = [1,2,3,0,0,0]
m = 3
vec2 = [2,5,6]
n = 3

Resultado esperado:[1, 2, 2, 3, 5, 6]

Minha tentativa de encontrar a complexidade do espaço e do tempo

tudo está funcionando bem, agora o que eu quero é descobrir a complexidade do tempo e do espaço. Eu descobri o seguinte:

A complexidade do espaço seria o tamanho do vetor total, certo? Neste caso acredito que seja O(m + n)

Quanto à complexidade do tempo, std::remove_if levaria no máximo m , então std::vector::erase e std::vector::insert levaria n (o número de elementos no segundo vetor) e finalmente std: :inplace_merge levaria O (n log n).

Então no final temos O(n log n + 2m + n) , estou correto?

Eu estava olhando algumas técnicas anti-desmontagem e me deparei com o seguinte trecho

push 0x33
call $+5
add [esp+0x10+var_10], 5
retf
next instruction here

Resumindo, isso pularia imediatamente para a instrução logo após o RETF, mas atrapalharia os desmontadores de 32 bits. Ainda não está claro para mim por que isso acontece

Agora, me disseram que o RETF retorna para um segmento de 64 bits e, portanto, depurar isso em um depurador de 32 bits produziu a desmontagem errada. Ao executar este trecho em um depurador de 64 bits (no meu caso, windbg), ele produz o resultado correto.

Minha pergunta aqui é: há algo especial no push 0x33? 0x33 é algum tipo de valor especial?

Eu tenho esta função que usa std::partition para dividir um contêiner em dois com base em um predicado.

template<class Container, class Predicate>
void split_partition(Container& src, Container& dest, Predicate p)
{

    auto ends = std::partition_copy(
        std::make_move_iterator( src.begin() ), std::make_move_iterator( src.end() ),
        src.begin(), std::back_inserter(dest), p
    ); 

    src.erase(ends.first, src.end());

}

Eu tentei ligar com

split_partition(a, b, [](auto& t) {return t.i > 4; });

mas nem compilou, agora se usar const funciona.

split_partition(a, b, [](const auto& t) {return t.i > 4; });

Por que é que?

Editar:

std::vector<Thing> a = { {0, "foo"}, {1, "bar"}, {5, "what"}, {8, "yo"}, {2, ""} };
std::vector<Thing> b;