标签: pointer-aliasing

我对类似主题和与之相关的一些材料进行了一些查询.但我的查询主要是了解下面代码的警告.我不想修复!! 我知道有两种方法,一个联合或使用memcpy.

uint32 localval;
void * DataPtr;
localval = something;
(*(float32*)(DataPtr))= (*(const float32*)((const void*)(&localval)));

请注意以下重点
1.这里涉及的两种类型都是32位.(或者我错了吗？)
2.两者都是局部变量.

编译器具体要点:
1.代码应该是平台无关的,这是一个要求!!
我在GCC编译,它按预期工作.(我可以将int重新解释为浮点数),这就是为什么我忽略了警告.

我的问题
1.编译器在此别名情况下可以执行哪些优化？
2.因为两者都会占用相同的大小(如果不是,请纠正我)这样的编译器优化的副作用是什么？
3.我可以安全地忽略警告或关闭别名吗？
4.如果编译器没有执行优化,我的程序在第一次编译后没有被破坏？我可以安全地假设每次编译器的行为方式都相同(不进行优化)吗？
5.别名是否也适用于void*类型转换？或者它是否仅适用于标准类型转换(int,float等...)？
6.如果禁用别名规则会有什么影响？

编辑
1.基于R和Matt McNabb的更正
2.增加了一个新问题

我正在尝试定义单例别名方法.如:

name = 'Bob'
# I want something similar to this to work
name.define_singleton_method(:add_cuteness, :+)
name = name.add_cuteness 'by'

我确信我可以将方法对象作为第二个参数传递.

我不想这样做

name.define_singleton_method(:add_cuteness) { |val| self + val }

我想别名String#+方法不使用它.强调别名,但将实际方法对象作为第二个参数发送也很酷.

我正在使用ojdbc7.jar从Java连接到oracle.对于走样查询,当我做getColumnName()和getColumnLabel()的ResultSetMetaData,都将返回别名.我想拥有原始列名.

我愿意对时间序列数据进行傅里叶变换，以将数据转换为频域。我不确定我用来进行傅立叶变换的方法是否正确？以下是我使用过的数据的链接。

读取数据文件后，我使用绘制了原始数据

t = np.linspace(0,55*24*60*60, 55)
s = df.values
sns.set_style("darkgrid")
plt.ylabel("Amplitude")
plt.xlabel("Time [s]")
plt.plot(t, s)
plt.show()

由于数据是按每日频率运行，因此我已使用将其转换为秒，24*60*60并使用进行了55天的转换55*24*60*60

该图如下所示：

接下来，我使用以下代码实现了傅立叶变换，并获得了如下图像：

#Applying Fourier Transform
fft = fftpack.fft(s)

#Time taken by one complete cycle of wave (seconds)
T = t[1] - t[0] 

#Calculating sampling frequency
F = 1/T

N = s.size

#Avoid aliasing by multiplying sampling frequency by 1/2 
f = np.linspace(0, 0.5*F, N)

#Convert frequency to mHz
f = f * 1000

#Plotting frequency domain against amplitude …

在不安全的代码中,只要它们不用于写入相同的索引,对同一个数组有几个可变引用(而不是指针)是否正确？

上下文

我想产生几个(不同的)底层数组的可变视图,我可以从不同的线程修改.

如果不相交的部分是连续的,那么通过调用split_at_mut切片这是微不足道的:

let mut v = [1, 2, 3, 4];
{
    let (left, right) = v.split_at_mut(2);
    left[0] = 5;
    right[0] = 6;
}
assert!(v == [5, 2, 6, 4]);

但我也希望揭露不连续的不相交部分.为简单起见,假设我们想为偶数索引检索可变"视图",为奇数索引检索另一个可变"视图".

相反split_at_mut(),我们无法检索两个可变引用(我们想要一个安全的抽象!),所以我们使用两个结构实例,只暴露偶数(相应的奇数)索引的可变访问:

let data = &mut [0i32; 11];
let (mut even, mut odd) = split_fields(data);
// …

使用一些不安全的代码,很容易获得这样一个安全的抽象.这是一个可能的实现:

use std::marker::PhantomData;

struct SliceField<'a> {
    ptr: *mut i32,
    len: usize,
    field: usize,
    marker: PhantomData<&'a mut i32>,
}

impl SliceField<'_> {
    fn …

我正在研究高度“可向量化”的代码，并注意到关于 C++ __restrict 关键字/扩展 ~，即使在简单的情况下，与 GCC 相比，Clang 的行为也是不同且不切实际的。

对于编译器生成的代码，速度减慢约 15 倍（在我的具体情况下，不是下面的示例）。

这是代码（也可在https://godbolt.org/z/sdGd43x75获取）：

struct Param {
    int *x;
};

int foo(int *a, int *b) {
    *a = 5;
    *b = 6;
    // No significant optimization here, as expected (for clang/gcc)
    return *a + *b;
}

int foo(Param a, Param b) {
    *a.x = 5;
    *b.x = 6;
    // No significant optimization here, as expected (for clang/gcc)
    return *a.x + *b.x;
}

/////////////////////

struct ParamR {
    // "Restricted pointers assert …

首先,我知道这是因为库不好,但我没有代码让他们解决这个问题.

XXX.dll在全局命名空间中包含类Util.Util.dll具有命名空间Util.

当我包含两个.dll时,我不能使用Util命名空间(错误1'..\Util.dll'中的命名空间'Util'与'\ XXX.dll'中的'Util'类型冲突).

因为两者都在全局命名空间中,所以我看不到别名如何解决这个问题.

什么是最好的解决方案？现在我知道我可以创建另一个.proj,它不包括我需要的.dll和包装类.但这不容易做到;(

这可能是一个奇怪的问题,但我需要知道OpenGL对绘制几何体的边缘(多边形,线条等)的别名是否"一致",这意味着它在不同的平台/硬件上看起来相同.

在这种情况下,混叠是"消除锯齿"旨在消除的锐边.我想要别名,并且希望将它用于需要混叠效果的像素完美的动画技术(它适用于精灵类效果).这是可行的,还是无法预测它在不同计算机上的别名？

有没有办法在python中获取列表的一部分的别名？

具体来说,我希望发生相同的事情:

>>> l=[1,2,3,4,5]
>>> a=l
>>> l[0]=10
>>> a
[10, 2, 3, 4, 5]

但我得到的是:

>>> l=[1,2,3,4,5]
>>> a=l[0:2]
>>> l[0]=10
>>> a
[1, 2]

它是安全的代码，还是编译器可以通过 优化访问p，从而*p导致42？

#include <stdio.h>

int i = 42;
int *d = &i;

void test(int const *p) 
{
    *d = 43;
    printf("%d, %p\n", *p, (void *) p);
    printf("%d, %p\n", *d, (void *) d);
}

int main() {
    test(d);
    return 0;
}

我发现*p通常打印为43，但我想知道这里是否有任何陷阱，因此在某些情况下打印*p可能会产生42。