Este array tem um tamanho de 1, mas eu posso inicializá-lo com esses valores, então eu posso até mesmo definir mais valores depois de instanciar o array e ele ainda funciona. Eu não entendo o porquê.
int array[1] = {12,2,12,12,12,31};
printf("%d\n",array[1]);
printf("%d\n",array[0]);
array[1] = 1;
array[8] = 3;
printf("%d\n",array[1]);// 1 It works. Why?
printf("%d\n",array[8]);// 3 It works. Why?
Digamos que eu tenha um array de ponteiros para structs. Como faço para que cada elemento do array aponte para um local de memória diferente, para que eu possa alterar esses valores de struct por meio de ponteiros individualmente?
Alguns exemplos de código:
struct Person {
int age;
char *name[64];
}
int main() {
struct Person *people[4];
struct Person tmp_person;
people[0] = &tmp_person;
people[0]->age = 12;
people[0]->name = "John";
people[1] = &tmp_person;
people[1]->age = 34;
people[1]->name = "Mike";
}
Aqui, cada elemento pessoa será o mesmo, já que todos os elementos do array apontam para a mesma memória ( tmp_person). Sei que o código está incorreto, estou apenas tentando fazer um exemplo. Então, como faço ponteiros únicos? Criar uma nova variável para cada elemento ( tmp_person1, tmp_person2, ...) parece estúpido e muito difícil.
Desde o OpenMP 4.5, arrays podem ser reduzidos usando pragmas. Mas, eu enfrentei um problema quando tentei usá-lo em arrays de tipo derivado porque !$OMP DECLARE REDUCTION não foi encontrado para este tipo. Eu entendo o problema. Depois de muitas tentativas, eu finalmente encontrei um programa que parece funcionar. Este é o código:
O módulo ( module.f90):
module my_mod
implicit none
type :: my_type_t
integer :: x
integer :: y
end type my_type_t
interface operator(+)
module procedure add_my_type_t_vec
end interface
!$OMP DECLARE REDUCTION (+ : my_type_t : omp_out = omp_out + omp_in) INITIALIZER (omp_priv = omp_orig)
contains
function add_my_type_t_vec(a,b) result(res)
type(my_type_t), dimension(:),intent(in) :: a, b
type(my_type_t), dimension(size(a)) :: res
res(:)%x = a(:)%x + b(:)%x
res(:)%y = a(:)%y + b(:)%y
end function add_my_type_t_vec
end module my_mod
E o programa ( pgm.f90) que o utiliza:
program parallel
use omp_lib
use my_mod
implicit none
type(my_type_t), dimension(:), allocatable :: private_var, shared_var
integer :: i
allocate(private_var(5), shared_var(5))
shared_var%x=0
shared_var%y=0
!$OMP PARALLEL NUM_THREADS(4) PRIVATE(private_var,i) REDUCTION (+ : shared_var)
!$OMP DO
do i=1,1000
private_var%x = 1
private_var%y = 2
shared_var = shared_var + private_var
end do
!$OMP END DO
!$OMP END PARALLEL
print *, "Total : ", shared_var
end program parallel
Compilação com:gfortran -fopenmp module.f90 pgm.f90
Para encontrar essa solução, usei a seguinte resposta https://stackoverflow.com/a/61148205/7462275 .
Funciona, mas não tenho certeza de que não terei comportamento indefinido em certas circunstâncias. E não entendo completamente a sintaxe e o mecanismo dos pragmas DECLARE REDUCTION e INITIALIZER. De fato, fiz uma cópia/colagem da resposta mencionada acima e não há explicação nela. Obrigado pelos conselhos e explicações.
Isso criará arr[0]=hy, arr[1]="hello man":
declare -a arr=(hy "hello man")
Eu tenho o 'hy "hello man"' como uma string inteira armazenada em uma variável tal que:
echo "$var"
hy "hello man"
Como posso dividi-lo de volta para uma matriz? Eu tentei IFS= IFS=" " readarraye tudo, exceto a matriz, só resulta em arr[0]="hy "hello man""e nãoarr[0]=hy, arr[1]="hello man"
Matriz desejada:
arr[0]=hy arr[1]="hello man"
Para fins de teste:
arg () { printf "%d args:" "$#"; [ "$#" -eq 0 ] || printf " <%s>" "$@"; echo; }
arg hy "hello man"
2 args: <hy> <hello man>
Mas
var='hy "hello man"'
arg $t
1 arg: <hy "hello man">
Existe algum truque de citação que possa ajudar com meu problema?
Digamos que eu tenha o seguinte arquivo CSV (sample.csv)
filepath1
filepath1,filepath2
filepath1,filepath2,filepath3
filepath1,filepath2,filepath3,filepath4
filepath1,filepath2
E o programa que preciso usar usa a seguinte sintaxe:
program_im_using --file filepath1
Mas se houver vários arquivos presentes, a sintaxe para entrada é:
program_im_using --file filepath1 --file filepath2
or
program_im_using --file filepath1 --file filepath2 --file filepath3
O que eu faria para colar os valores do arquivo CSV seria algo assim:
filepath_first=( $(awk -F "\"*,\"*" '{print $1}' $sample_csv) )
filepath_second=( $(awk -F "\"*,\"*" '{print $2}' $sample_csv) )
for i in "${!filenames[@]}"; do
program_im_using --file "${filepath_first[i]}" --file "${filepath_second[i]}"
done
Meu exemplo do que estou fazendo só funciona se eu tiver exatamente 2 colunas de valores em cada linha. Como posso generalizar de forma que, se eu tiver uma coluna, eu obtenha:
program_im_using --file filepath1
Mas se eu tiver dois
program_im_using --file filepath1 --file filepath2
etc?
Tenho uma string que contém uma matriz de objetos JSON. Usando Golang, quero remover um ou mais campos especificados de cada objeto na matriz e, em seguida, imprimir o resultado stringificado. Preciso aplicar esse processo de remoção de campo a vários formatos de entrada JSON diferentes e, portanto, não quero usar um modelo. Aqui está um código esqueleto com uma forma de entrada de exemplo e saída desejada:
package main
import (
"fmt"
)
func functionDropSpecifiedFields(inputString string, fields []string) string {
var outputString string
// Need some logic here to remove each field in array 'fields'!
return outputString
}
func main() {
jsonArrayAsString := `[{"name":"Marlon","age":25,"created_at":"2025-02-10T08:51:14.615264Z"},{"name":"Wendy","age":31,"created_at":"2025-11-14T08:46:09.435264Z"}]`
fieldsToRemove := []string{"created_at"}
reducedString := functionDropSpecifiedFields(jsonArrayAsString, fieldsToRemove)
fmt.Println(reducedString)
// Should print: [{"name":"Marlon","age":25},{"name":"Wendy","age":31}]
}
Qual lógica na função DropSpecifiedFields conseguirá isso?
Estou usando a versão mais recente do g++ para compilar um código de teste envolvendo um array de ponteiros struct onde os structs contêm um array. A compilação falha quando tento inicializar o array de ponteiros struct em uma linha, mas se eu atribuir os structs a variáveis e então pegar seus endereços ao criar o array, o g++ não reclama. Quero entender o porquê. Este é meu primeiro post, então peço desculpas se houver informações faltando.
Procurei por perguntas semelhantes e não encontrei nada tão específico.
#include <stdint.h>
typedef struct {
uint16_t num_elements;
uint8_t elements[];
} HasArray;
HasArray x = {.num_elements = 2, .elements = {51, 17}};
HasArray y = {.num_elements = 4, .elements = {1, 42, 88, 73}};
const HasArray* collection[] = {&x, &y};
// main() somewhere
O código acima funciona, o que eu presumo que seja porque o g++ pode alocar memória para xe yem tempo de compilação (ou algo similar). Se eu tentar inicializar collectionassim:
// HasArray cast is necessary so I can take the address, doing `&` on just the `{}`
// didn't work
// Also I would use a macro for these declarations, I know it's clunky
const HasArray* collection[] = {
&(HasArray){.num_elements = 2, .elements = {51, 17}},
&(HasArray){.num_elements = 4, .elements = {1, 42, 88, 73}}
};
g++ lança
test.c:16:56: error: non-static initialization of a flexible array member
16 | &(HasArray){.num_elements = 2, .elements = {51, 17}},
| ^
test.c:17:63: error: non-static initialization of a flexible array member
17 | &(HasArray){.num_elements = 4, .elements = {1, 42, 88, 73}}
| ^
O que torna essas situações diferentes? No meu cérebro, a segunda sintaxe ainda alocará memória em tempo de compilação, mas parece que não é o caso. Eu entendo que eu poderia alocar memória em tempo de execução com malloc(), mas a primeira situação não requer isso e eu sei o tamanho das structs em tempo de compilação, então como posso indicar o tamanho para o compilador sem criar variáveis separadas para cada struct?
Editar: Eu de fato marquei a pergunta incorretamente, opa. Isso é para código c, mas tenho que usar g++ para compilá-lo. @ChrisMM forneceu uma resposta muito boa nos comentários. Para contornar o erro, atribuirei os arrays a variáveis e pegarei seus endereços como na primeira situação.
Intervalo de células começando na região Sheet1.Range("A2") com fórmulas. A string "No DATA" é constante se nada for extraído conforme a fórmula e eu não quero que ela seja incluída na matriz 1-D durante a transferência da matriz 2-D. Depois que a matriz 1-D estiver pronta, eu quero colar a matriz 1-D na planilha "Result" na célula "B:2" e para baixo. Eu tentei soluções online para isso. Mas as matrizes estão ficando complicadas para mim. O novo código também está bom. Eu coletei o código abaixo de fontes diferentes.
Sub TwoD_ArrayTo_1D_Array()
Dim rg As Range
'First row is always blank, so started with cell A2 & range contains formula
Sheet1.Range("A2").Select
Set rg = Sheet1.Range("A2").CurrentRegion
Dim arr As Variant, arr1D() As Variant
arr = rg.Value
Dim i As Long, j As Long, k As Long, rows As Long, totalrows As Long
totalrows = (rg.rows.Count - 1) * (rg.Columns.Count)
k = 1
ReDim arr1D(1)
'Convert 2D to 1D array
For i = i To (rg.rows.Count - 1)
For j = 1 To rg.Columns.Count
If arr(i, j).Value = "No DATA" Then 'dont want to copy cell if it contains "No DATA"
GoTo Next_Row
Else
arr1D(k) = arr(i, j)
k = k + 1
ReDim Preserve arr1D(k)
End If
Next_Row: Next j
Next i
'Pasting array values in "Result" Sheet
Dim iRw As Integer
For iRw = LBound(arr1D) To UBound(arr1D)
Result.Cells(iRw, 2).Value = arr1D(iRw, 1)
Next iRw
End Sub
Eu achava que arrays eram considerados estruturas de dados estáticas .
Então executamos isto:
#include <stdio.h>
#include <stdlib.h>
int main()
{
int a[5] = {10,20,30,40,50};
a[5] = 100;
a[6] = 200;
printf("Out of bounds %d, %d", a[5], a[6]);
return 0;
}
Isso retorna Out of bounds 100 200e termina normalmente. POR QUÊ?
Por que 200 é declarado e retornado normalmente se a[5]é estático?
Tudo me leva à conclusão de que o gcc trata matrizes como estruturas de dados dinâmicas.
Estou certo? O que está acontecendo?
Posso remover facilmente o primeiro elemento de uma matriz:
SELECT (ARRAY[1,2,3])[2:]
--{2,3}
Qual é a maneira mais simples de remover o último elemento também? O tamanho é dinâmico e não é conhecido em tempo de compilação.