¿Cuál es la diferencia entre enlace estático y dinámico?

Los tiempos de enlace se pueden clasificar en dos tipos: estáticos y dinámicos. ¿Cuál es la diferencia entre enlace estático y dinámico?

¿Podría dar un ejemplo rápido de cada uno para ilustrarlo mejor?

Solución del problema

En los términos más generales, el enlace estático significa que las referencias se resuelven en tiempo de compilación.

Animal a = new Animal();
a.Roar(); // The compiler can resolve this method call statically.

El enlace dinámico significa que las referencias se resuelven en tiempo de ejecución.

public void MakeSomeNoise(object a) {
 // Things happen...
 ((Animal) a).Roar(); // You won't know if this works until runtime!
}

La mejor manera de leer una estructura sin procesar de un archivo

Fondo (Omitible)

En Linux, el archivo /var/run/utmpcontiene varias utmpestructuras, cada una en formato binario sin procesar, que se suceden en un archivo. utmpen sí mismo es relativamente grande (384 bytes en mi máquina). Estoy tratando de leer este archivo en sus datos sin procesar, y luego implementan controles después del hecho de que los datos tienen sentido. No soy nuevo en el óxido, pero esta es mi primera experiencia real con el lado inseguro de las cosas.

Planteamiento del problema

Tengo un archivo que contiene varios c sturct utmps ( docs ). En rust, me gustaría leer el archivo completo en una matriz de archivos Vec<libc::utmpx>. Más específicamente, dado un lector abierto a este archivo, ¿cómo podría leer uno struct utmp?

What I have so far

A continuación se muestran tres implementaciones diferentes de read_raw, que acepta un lector y devuelve un RawEntry(mi alias para struct utmp). ¿Qué método es el más correcto? Estoy tratando de escribir un código con el mayor rendimiento posible, y me preocupa que read_raw0pueda ser más lento que los demás si se trata de memcpys. ¿Cuál es la forma mejor/más rápida de lograr este comportamiento?

use std::io::Read;
use libc::utmpx as RawEntry;
const RawEntrySize = std::mem::size_of::<RawEntry>();
type RawEntryBuffer = [u8; RawEntrySize];
/// Read a raw utmpx struct
// After testing, this method doesn't work
pub fn read_raw0<R: Read>(reader: &mut R) -> RawEntry {
 let mut entry: RawEntry = unsafe { std::mem::zeroed() };
 unsafe {
 let mut entry_buf = std::mem::transmute::<RawEntry, RawEntryBuffer>(entry);
 reader.read_exact(&mut entry_buf[..]);
 }
 return entry;
}
/// Read a raw utmpx struct
pub fn read_raw1<R: Read>(reader: &mut R) -> RawEntry {
 // Worried this could cause alignment issues, or maybe it's okay 
 // because transmute copies
 let mut buffer: RawEntryBuffer = [0; RawEntrySize];
 reader.read_exact(&mut buffer[..]);
 let entry = unsafe {
 std::mem::transmute::<RawEntryBuffer, RawEntry>(buffer)
 };
 return entry;
}
/// Read a raw utmpx struct
pub fn read_raw2<R: Read>(reader: &mut R) -> RawEntry {
 let mut entry: RawEntry = unsafe { std::mem::zeroed() };
 unsafe {
 let entry_ptr = std::mem::transmute::<&mut RawEntry, *mut u8>(&mut entry);
 let entry_slice = std::slice::from_raw_parts_mut(entry_ptr, RawEntrySize);
 reader.read_exact(entry_slice);
 }
 return entry;
}

Nota: Después de más pruebas, parece read_raw0que no funciona. Creo que esto se debe a que transmutar crea un nuevo búfer en lugar de hacer referencia a la estructura.

Solución del problema

Esto es lo que se me ocurrió, que imagino que debería ser lo más rápido posible para leer una sola entrada. Sigue el espíritu de tu última entrada, pero evita la transmutación (Transmutar &mut Ta *mut u8se puede hacer con dos lanzamientos: t as *mut T as *mut u8). También usa MaybeUniniten lugar de zeroedser un poco más explícito (el ensamblaje probablemente sea el mismo una vez optimizado). Por último, la función no será segura de ninguna manera, por lo que también podemos marcarla como tal y eliminar los unsafebloqueos.

use std::io::{self, Read};
use std::slice::from_raw_parts_mut;
use std::mem::{MaybeUninit, size_of};
pub unsafe fn read_raw_struct<R: Read, T: Sized>(src: &mut R) -> io::Result<T> {
 let mut buffer = MaybeUninit::uninit();
 let buffer_slice = from_raw_parts_mut(buffer.as_mut_ptr() as *mut u8, size_of::<T>());
 
 src.read_exact(buffer_slice)?;
 Ok(buffer.assume_init())
}

¿Cómo usar la etiqueta de imagen dinámica/variable en una implementación de Kubernetes?

In our project, which also uses Kustomize, our base deployment.yaml file looks like this:

apiVersion: apps/v1
kind: Deployment
metadata:
 name: nginx-deployment
 labels:
 app: nginx
spec:
 replicas: 3
 selector:
 matchLabels:
 app: nginx
 template:
 metadata:
 labels:
 app: nginx
 spec:
 containers:
 - name: nginx
 image: nginx:IMAGE_TAG # <------------------------------
 ports:
 - containerPort: 80

Luego usamos sedpara reemplazar IMAGE_TAGcon la versión de la imagen que queremos implementar.

¿Hay una forma más sofisticada de hacer esto, en lugar de editar el archivo de texto yaml usando sed?

Solución del problema

Hay un transformador específico para esto llamado transformador de imágenes. Puede mantener su implementación tal como está, con o sin etiqueta:

apiVersion: apps/v1
kind: Deployment
metadata:
 name: nginx-deployment
 labels:
 app: nginx
spec:
 replicas: 3
 selector:
 matchLabels:
 app: nginx
 template:
 metadata:
 labels:
 app: nginx
 spec:
 containers:
 - name: nginx
 image: nginx
 ports:
 - containerPort: 80

y luego en su archivo de personalización:

apiVersion: kustomize.config.k8s.io/v1beta1
kind: Kustomization
resources:
 - deployment.yaml
images:
 - name: nginx
 newTag: MYNEWTAG

Tenga en cuenta que esto reemplazará la etiqueta de todas las imágenes nginx de todos los recursos incluidos en su archivo de personalización. Si necesita ejecutar varias versiones de nginx, puede reemplazar el nombre de la imagen en su implementación por un marcador de posición y tener diferentes entradas en el transformador.

Las llamadas de SwiftUI que se pueden buscar en una lista combinan todos los elementos en una fila

In the example below the list items get squished all into one cell of the list, but only when calling.searchable() on it. When I call.searchable() on the text everything displays normally. I can't use it on the text though, because it has problems with the search filter.

import SwiftUI
struct FoodItem: Identifiable {
 let id = UUID()
 let name: String
}
struct ListView: View {
 
 let listContent: [FoodItem] = [FoodItem(name: "Food 1"), FoodItem(name: "Food 2")]
 @State public var searchQuery: String = ""
 
 var body: some View {
 NavigationView {
 Form {
 Section {
  List(filteredContent) { item in
  Text(item.name)
  }
 .searchable(text: $searchQuery)
 }
 }.navigationTitle("Food List")
 }
 }
 
 var filteredContent: [FoodItem] {
 if searchQuery.isEmpty {
 return listContent
 } else {
 return listContent.filter { $0.name.localizedCaseInsensitiveContains(searchQuery)}
 }
 }
}
struct ListView_Previews: PreviewProvider {
 static var previews: some View {
 ListView()
 }
}

Probablemente pasé dos horas buscando en línea e intentando arreglarlo y no encontré ningún resultado. Además, soy nuevo en SwiftUI.

¡¡Gracias!!

Solución del problema

El comentario de Paulw11 me ayudó mucho. Descubrí que ese no era el problema, que llamé a.searchable() en el texto, pero que tenía un error en mi filteredContent.

El problema se solucionó con esto:

var filteredContent: [FoodItem] {
 if searchQuery.isEmpty {
 return listContent
 } else if (listContent.filter {$0.name.localizedCaseInsensitiveContains(searchQuery)}.isEmpty) {
 return listContent
 } else {
 return listContent.filter { $0.name.localizedCaseInsensitiveContains(searchQuery)}
 }
}

¿Por qué no puedo iterar dos veces sobre los mismos datos?

¿Por qué no puedo iterar dos veces sobre el mismo iterador?

# data is an iterator.
for row in data:
 print("doing this one time")
for row in data:
 print("doing this two times")

Esto se imprime "doing this one time"varias veces, ya dataque no está vacío. Sin embargo, no imprime "doing this two times". ¿Por qué la iteración datafunciona la primera vez, pero no la segunda?

Solución del problema

Los iteradores (por ejemplo, de llamadas iter, de expresiones generadoras o de funciones generadoras que yield) tienen estado y solo se pueden consumir una vez, como se explica en la respuesta de Óscar López. Sin embargo, la recomendación de esa respuesta para usar itertools.tee(data)en lugar de list(data)por razones de rendimiento es engañosa.

En la mayoría de los casos, cuando desea iterar por todo datay luego repetirlo por completo, teetoma más tiempo y usa más memoria que simplemente consumir todo el iterador en una lista y luego iterarlo dos veces. teepuede ser preferible si solo consumirá los primeros elementos de cada iterador, o si alternará entre consumir algunos elementos de un iterador y luego algunos del otro.

"no hay función coincidente para llamar a" cuando se tiene un puntero de función con argumentos de plantilla como argumento de plantilla

Estoy escribiendo una función contenedora de plantilla que se puede aplicar a funciones con diferentes números/tipos de argumentos. Tengo un código que funciona pero estoy tratando de cambiar más argumentos en parámetros de plantilla.

El código de trabajo:

#include <iostream>
int func0(bool b) { return b? 1: 2; }
//There is a few more funcX...
template<typename...ARGS>
int wrapper(int (*func)(ARGS...), ARGS... args) { return (*func)(args...) * 10; }
int wrappedFunc0(bool b) { return wrapper<bool>(func0, b); }
int main()
{
 std::cout << wrappedFunc0(true) << std::endl;
 return 0;
}

Ahora quiero int (*func)(ARGS...)ser también un parámetro de plantilla. (Es por razones de rendimiento. Quiero que el puntero esté respaldado en el contenedor, porque la forma en que lo estoy usando evita que el compilador lo optimice).

Esto es lo que se me ocurrió (la única diferencia es que cambié el único argumento en un parámetro de plantilla):

#include <iostream>
int func0(bool b) { return b? 1: 2; }
//There is a few more funcX...
template<typename...ARGS, int (*FUNC)(ARGS...)>
int wrapper(ARGS... args) { return (*FUNC)(args...) * 10; }
int wrappedFunc0(bool b) { return wrapper<bool, func0>(b); }
int main()
{
 std::cout << wrappedFunc0(true) << std::endl;
 return 0;
}

Esto no compila. Muestra:

<source>: In function 'int wrappedFunc0(bool)':
<source>:9:55: error: no matching function for call to 'wrapper<bool, func0>(bool&)'
 9 | int wrappedFunc0(bool b) { return wrapper<bool, func0>(b); }
 |   ~~~~~~~~~~~~~~~~~~~~^~~
<source>:7:5: note: candidate: 'template<class... ARGS, int (* FUNC)(ARGS...)> int wrapper(ARGS...)'
 7 | int wrapper(ARGS... args) { return (*FUNC)(args...) * 10; }
 | ^~~~~~~
<source>:7:5: note: template argument deduction/substitution failed:
<source>:9:55: error: type/value mismatch at argument 1 in template parameter list for 'template<class... ARGS, int (* FUNC)(ARGS...)> int wrapper(ARGS...)'
 9 | int wrappedFunc0(bool b) { return wrapper<bool, func0>(b); }
 |   ~~~~~~~~~~~~~~~~~~~~^~~
<source>:9:55: note: expected a type, got 'func0'
ASM generation compiler returned: 1
<source>: In function 'int wrappedFunc0(bool)':
<source>:9:55: error: no matching function for call to 'wrapper<bool, func0>(bool&)'
 9 | int wrappedFunc0(bool b) { return wrapper<bool, func0>(b); }
 |   ~~~~~~~~~~~~~~~~~~~~^~~
<source>:7:5: note: candidate: 'template<class... ARGS, int (* FUNC)(ARGS...)> int wrapper(ARGS...)'
 7 | int wrapper(ARGS... args) { return (*FUNC)(args...) * 10; }
 | ^~~~~~~
<source>:7:5: note: template argument deduction/substitution failed:
<source>:9:55: error: type/value mismatch at argument 1 in template parameter list for 'template<class... ARGS, int (* FUNC)(ARGS...)> int wrapper(ARGS...)'
 9 | int wrappedFunc0(bool b) { return wrapper<bool, func0>(b); }
 |   ~~~~~~~~~~~~~~~~~~~~^~~
<source>:9:55: note: expected a type, got 'func0'
Execution build compiler returned: 1

( enlace al explorador del compilador )

Me parece un problema con el compilador, pero GCC y Clang están de acuerdo, así que tal vez no lo sea.

De todos modos, ¿cómo puedo hacer que esta plantilla se compile correctamente con un puntero con plantilla a una función?

EDITAR: abordar el problema de compilación de bandera duplicada con la creación de instancias de la plantilla de función
. Creo que el núcleo del problema en esa pregunta es el mismo que en el mío, sin embargo, carece de una solución que permita pasar el puntero para que funcione (no solo su tipo) como parámetro de plantilla.

Solución del problema

Esto no funciona porque un parámetro de paquete (el que incluye ...) consume todos los argumentos restantes. Todos los argumentos que le siguen no pueden especificarse explícitamente y deben deducirse.

Normalmente escribes tales envoltorios como este:

template <typename F, typename...P>
int wrapper(F &&func, P &&... params)
{
 return std::forward<F>(func)(std::forward<P>(params)...) * 10;
}

(Y si la función se llama más de una vez dentro del contenedor, todas las llamadas, excepto la última, no se pueden usar std::forward).

Esto pasará la función por referencia, que debería ser exactamente lo mismo que usar un puntero de función, pero no tengo razones para creer que impediría que el compilador la optimice.

You can force the function to be encoded in the template argument by passing std::integral_constant<decltype(&func0), func0>{} instead of func0, but again, I don't think it's going to change anything.

MySQL: encuentre una palabra específica de la base de datos SQL

SELECT * FROM Employee WHERE CONCAT(name) LIKE '% irfan %';
Table
Irfan Khan
Irfan Chisti
Irfan
Irfan Bhatti

Quiero el resultado como en la clasificación.

Producción:

Irfan
Irfan Bhatti
Irfan Chisti
Irfan Khan

Solución del problema

No está claro cómo se ven exactamente su tabla y columnas y qué propósito debería tener el "concat" en su ejemplo. Generalmente, puede ordenar usando la palabra clave "ORDER BY", así que en su caso:

SELECT * FROM employee WHERE name LIKE '%irfan%' ORDER BY name

En caso de que el nombre completo esté en una columna, esto funcionará correctamente. De lo contrario, podría ser necesario concatenar nombre y apellido o similar. Si necesita más información, agregue más detalles a su pregunta.