标签: pointers

哪些字符应该用于ptrdiff_t在printf？

请问C标准明确说明如何打印ptrdiff_t的printf？我还没找到任何人.

int a = 1;
int b = 2;

int* pa = &a;
int* pb = &b;

ptrdiff_t diff = b - a;

printf("diff = %?", diff); // % what?

出于教育目的,我正在编写一组方法,这些方法会导致C#中的运行时异常,以了解所有异常是什么以及导致它们的原因.现在,我正在修补导致问题的程序AccessViolationException.

对我来说最明显的方法是写入受保护的内存位置,如下所示:

System.Runtime.InteropServices.Marshal.WriteInt32(IntPtr.Zero, 0);

正如我所希望的那样,这引起了人们的注意AccessViolationException.我想更简洁地做到这一点,所以我决定用不安全的代码编写程序,并通过分配0零指针来做(我认为的)完全相同的事情.

unsafe
{
    *(int*)0 = 0;
}

由于无法理解的原因,这引发了一个问题NullReferenceException.我玩了一些,并发现使用*(int*)1而不是抛出一个NullReferenceException,但如果你使用负数,就像*(int*)-1它会抛出一个AccessViolationException.

这里发生了什么？为什么*(int*)0 = 0导致a NullReferenceException,为什么不导致AccessViolationException？

我正在开发一个项目,我需要我的CUDA设备在包含指针的结构上进行计算.

typedef struct StructA {
    int* arr;
} StructA;

当我为结构分配内存然后将其复制到设备时,它只会复制结构而不是指针的内容.现在我通过首先分配指针来解决这个问题,然后将主机结构设置为使用新指针(位于GPU上).以下代码示例使用上面的结构描述了此方法:

#define N 10

int main() {

    int h_arr[N] = {1,2,3,4,5,6,7,8,9,10};
    StructA *h_a = (StructA*)malloc(sizeof(StructA));
    StructA *d_a;
    int *d_arr;

    // 1. Allocate device struct.
    cudaMalloc((void**) &d_a, sizeof(StructA));

    // 2. Allocate device pointer.
    cudaMalloc((void**) &(d_arr), sizeof(int)*N);

    // 3. Copy pointer content from host to device.
    cudaMemcpy(d_arr, h_arr, sizeof(int)*N, cudaMemcpyHostToDevice);

    // 4. Point to device pointer in host struct.
    h_a->arr = d_arr;

    // 5. Copy struct from host to device.
    cudaMemcpy(d_a, h_a, sizeof(StructA), …

可能重复:
C++:何时使用引用与指针
运算符重载是否可以在没有引用的情况下工作？

我无法帮助它,但这个基本问题在我的脑海里浮现:为什么C++在你可以使用指针时也有引用？

我知道在某些情况下它们会稍微安全一些,而且往往使代码更漂亮,但从技术上讲,没有区别,对吧？那么有什么情况我不能用指针和引用是必须的吗？
我想看看何时使用引用的具体例子是不可避免的.

免责声明:
我在StackOverflow上没有找到任何答案,这不是关于语法差异的问题.我想知道为什么C++语言首先引入了引用.

这个网站上的第一个计时器,所以这里..

我是C++的新手,我目前正在阅读"DS Malik的数据结构使用C++第二版"一书.

在书中,Malik提供了两种创建动态二维数组的方法.在第一种方法中,将变量声明为指针数组,其中每个指针都是整数类型.恩.

int *board[4];

..然后使用for循环创建'列',同时使用指针数组作为'行'.

第二种方法,您使用指针指针.

int **board;
board = new int* [10]; 

等等

我的问题是:哪种方法更好？**方法对我来说更容易可视化,但第一种方法可以大致相同的方式使用.两种方式都可用于制作动态二维数组.

编辑:上面的帖子不够清楚.这是我尝试过的一些代码:

int row, col;

cout << "Enter row size:";
cin >> row;
cout << "\ncol:";
cin >> col;

int *p_board[row];
for (int i=0; i < row; i++)
    p_board[i] = new int[col];

for (int i=0; i < row; i++)
{
    for (int j=0; j < col; j++)
    {
        p_board[i][j] = j;
        cout << p_board[i][j] << " ";
    }
    cout << endl;
}
cout << …

来自Rust指南:

要取消引用(获取引用的值而不是引用本身)y,我们使用星号(*)

所以我做到了:

fn main() {
    let x = 1;
    let ptr_y = &x;
    println!("x: {}, ptr_y: {}", x, *ptr_y);
}

即使没有明确的解引用,这也给了我相同的结果(x = 1; y = 1):

fn main() {
    let x = 1;
    let ptr_y = &x;
    println!("x: {}, ptr_y: {}", x, ptr_y);
}

为什么？不应该ptr_y打印内存地址并*ptr_y打印1？是否有某种自动解除引用或者我错过了什么？

今天我读了一个让我感到困惑的C片段:

#include <stdio.h>

int
main(void)
{
    int a[] = {0, 1, 2, 3};

    printf("%d\n", *(*(&a + 1) - 1));
    return 0;
}

在我看来,&a + 1毫无意义,但它运行没有错误.

有人可以解释一下这意味着什么,谢谢.K&R C圣经是否涵盖了这一点？

UPDATE0:读完答案后,我意识到这两个表达式主要让我困惑:

1. &a + 1,在SO中被问到:关于c中的表达"&anArray"

2. *(&a + 1) -1,这与阵列衰减有关.

为什么以下代码会发出警告？

int main(void)
{
    struct {int x; int y;} test = {42, 1337};
    struct {int x; int y;} *test_ptr = &test;
}

结果:

warning: initialization from incompatible pointer type [-Wincompatible-pointer-types]
         struct {int x; int y;} *test_ptr = &test;
                                            ^

让我们考虑一个对象foo(可能是一个int,一个double,一个习惯struct,一个class,等等).我的理解是,通过foo引用函数(或只是传递指针foo)来传递更高的性能,因为我们避免制作本地副本(如果foo很大则可能很昂贵).

但是,从这里的答案来看,似乎64位系统上的指针实际上可以预期大小为8字节,无论指向什么.在我的系统上,a float是4个字节.这是否意味着如果foo是类型float,那么仅通过值传递而不是给它指向它是更有效的foo(假设没有其他约束可以使得使用一个比函数内的另一个更有效)？

在C/C++中,仅当结果指针位于原始指向的完整对象内时,才定义指针的加法或减法.此外,只有当两个指向对象是唯一完整对象的子对象时,才能执行两个指针的比较.

这种限制的原因是什么？

我认为分段内存模型(参见这里 §1.2.1)可能是其中一个原因,但由于编译器实际上可以定义所有指针的总顺序,如本答案所示,我对此表示怀疑.