相关疑难解决方法(0)

做这个...

char* myString = "hello";

......有同样的效果吗？

char actualString[] = "hello";
char* myString = actualString;

我在两个代码中做同样的事情.

在代码1中:我使用了a char *并使用mallocin 分配空间main.

在代码2中:我使用了一个char数组用于相同的目的.但为什么输出会有所不同？

代码1:

struct node2
{
    int data;
    char p[10];
}a,b;

main()
{
    a.data = 1;

    strcpy(a.p,"stack");
    b = a;
    printf("%d %s\n",b.data,b.p);     // output 1 stack
    strcpy(b.p,"overflow"); 
    printf("%d %s\n",b.data,b.p);     // output  1 overflow
    printf("%d %s\n",a.data,a.p);     // output  1 stack
}

代码2:

struct node1
{
    int data;
    char *p;
}a,b;

main()
{
    a.data = 1;
    a.p = malloc(100);
    strcpy(a.p,"stack");
    b = a;
    printf("%d %s\n",b.data,b.p);   //output 1 stack
    strcpy(b.p,"overflow");  
    printf("%d %s\n",b.data,b.p); …

这是strCopy的一个实现

void strcopy2(char *dst, char const *src){
    while ((*dst++ = *src++))
        ;
}

我们的教授要求我们在不使用指针的情况下重现这段代码,所以我想出了以下函数:

void strcopy(char dst[], char const src[]){
    size_t i = 0;
    while (dst[i] = src[i++])
        ;
}

它运行良好,但我意识到,在引擎盖下,函数必须仍然使用指针,因为我们无处可返回任何值.换句话说,我虽然最后一个函数会使用pass by value但显然并非如此.那么在水下发生了什么,这两种方法之间究竟有什么区别吗？

#include <iostream>
void ArraySize(int arrMyarr[])
{
    std::cout << sizeof(arrMyarr) << '\n';
}

void ArraySize1(int *arrMyarr)
{
    std::cout << sizeof(arrMyarr) << '\n';
}

int main()
{
    int arrTemp[] = { 122, 11, 22, 63, 15, 78, 143, 231 };
    std::cout << sizeof(arrTemp) << '\n';
    ArraySize(arrTemp);
    ArraySize1(arrTemp);
    return 0;
}

输出:32 4 4

以下两个函数声明是否相同？

void ArraySize(int arrMyarr[]);

void ArraySize1(int *arrMyarr);

我已经发现(1,2)的是:

char s[] = "abc";
char t[3] = "abc";

实际上与:

char s[] = { 'a', 'b', 'c', '\0' };
char t[] = { 'a', 'b', 'c' };

以下内容:

char *word = "abc";
word[0] = 'd';

地方word在只读存储器,导致非法内存操作word[0] = 'd'错误.

这只是chars 的情况吗？当我做这样的事情时,我不会得到错误:

int array[] = {1, 2, 3};
int *p = array;
p[0] = 0; // No error here
array[1] = 1; // or here

我经常听到数组的名称是指向一块内存的常量指针,因此语句就像

int a[10];

和

int * const p= a;

在某种意义上,p必须是相等的,p是指向与数组a []相同的内存块的指针,并且它也可能不会被更改为指向内存中的另一个位置.

但是,如果您尝试打印这两个指针的大小,则会得到不同的结果:

cout<< sizeof(a); // outputs size of 10 integer elements

而

cout<< sizeof(p); // outputs sizeof pointer to int

那么,为什么编译器会以不同的方式对待这两者？从编译器的角度来看,数组和指针之间的真正关系是什么？