केवल पॉइंटर रेफरेंसिंग/डेरेफेरेंसिंग का उपयोग करके 2 m*n मैट्रिसेस जोड़ने के लिए एक प्रोग्राम लिखें। यही है, किसी भी सरणी के उपयोग की अनुमति नहीं है। मेरा कोड इस प्रकार है:

#include<stdio.h>
int main()
{
    int row,col;
    scanf("%d %d",&row,&col);
    int* ptr1;
    int* ptr2 = ptr1 + (row*col);/*if ptr1+(row*col) is not there then runtime error is given*/
    int* ptr3 = ptr2 + (row*col);
    for(int i=1;i<=(row*col);i++)
    {
        scanf("%d",(ptr1+i));
    }
    for(int i=1;i<=(row*col);i++)
    {
        scanf("%d",(ptr2+i));
        *(ptr3+i)=(*(ptr1+i) + *(ptr2+i));
    }
    for(int i=1;i<=(row*col);i++)
    {
        printf("%d ",(*(ptr3+i)));
        if(i%col == 0) printf("\n");
    }
    return 0;
}

समस्या यह है कि यह 3 * 3 मैट्रिक्स तक ठीक काम करता है और उसके बाद यह रनटाइम त्रुटि देता है।

0
Abhishek Kumar 18 मई 2020, 17:58
1
आप जो वास्तविक त्रुटि देख रहे हैं वह क्या है? मैं आपको कोई मेमोरी आवंटित करते हुए नहीं देखता, इसलिए आप एक segfault देखने जा रहे हैं।
 – 
Christopher Schneider
18 मई 2020, 18:00
1
आप *(ptr + disp) संकेतन का उपयोग करने पर जोर क्यों देते हैं, इसके बजाय अधिक जटिल 3[ptr] का उपयोग क्यों न करें... यदि आप अपठनीय कोड लिखना चाहते हैं, तो मैं आपकी मदद कर सकता हूं... लेकिन आपको इसके लिए पूछने की आवश्यकता है यह।
 – 
Luis Colorado
20 मई 2020, 01:23

3 जवाब

  1. आपको malloc या इसी तरह का उपयोग करके ढेर पर अपने सरणी के लिए स्थान आवंटित करने की आवश्यकता है:
#include <stdlib.h>
...
    int* ptr1 = malloc(3 * (row*col) * sizeof(int));
...
  1. आपके लूप 0 से शुरू होकर (row*col)-1 पर खत्म होने चाहिए।
...
    for(int i=0;i<=(row*col)-1;i++)
...

... या अधिक परंपरागत रूप से:

...
    for(int i=0;i<(row*col);i++)
...
1
rtx13 18 मई 2020, 18:08
  1. मैट्रिक्स को कहाँ परिभाषित किया गया है? आप क्यों लिखते हैं:
 int row,col;
 scanf("%d %d",&row,&col);
 int* ptr1;  /* <<<WERE DO YOU INITIALIZE THIS ****POINTER**** ???>>> */
 int* ptr2 = ptr1 + (row*col);/*if ptr1+(row*col) is not there then runtime error is given*/  /* <<<BUT YOU ARE USING ITS VALUE HERE !!! >>> */
 int* ptr3 = ptr2 + (row*col);
  1. सी में एक सूचक, किसी भी प्रकार की सरणी के समान नहीं है। उनके पास ऐसे उपयोग हैं जो आपको कुछ बिंदुओं पर उनकी भूमिकाओं को बदलने की अनुमति देते हैं, लेकिन जब आप क्षेत्र पर हावी होते हैं। तब तक, इस बात से अवगत रहें कि एक सूचक और एक सरणी बहुत अलग चीजें हैं

सूचक

जैसा कि आपने ऊपर परिभाषित किया है, आपने एक सूचक को परिभाषित किया है। एक पॉइंटर मेमोरी में किसी चीज़ का पता रखता है, और इसलिए, केवल एक एड्रेस स्टोरेज के लिए जगह होती है।

एक सूचक की घोषणा:

int *reference;

सरणी

एक सरणी एक वस्तु है जो एक निश्चित (संकलन समय पर) तत्वों की संख्या के लिए भंडारण प्रदान करती है, वे सभी एक ही प्रकार के होते हैं।

एक सरणी की घोषणा:

int vector[100]; /* this is an array of 100 ints */

यदि आप चाहते हैं कि आपका पॉइंटर सरणी के कुछ तत्वों को इंगित करे, तो आप इसे इसका पता निर्दिष्ट कर सकते हैं, जैसे कुछ:

reference = &vector[53];

और आप reference द्वारा इंगित तत्व तक पहुंच सकते हैं:

printf("the 54th element of the array is %d\n", *reference);

या

printf("the 54th element of the array is %d\n", vector[53]);

(चूंकि सरणियाँ शून्य आधारित हैं, पहला तत्व vector[0] है, दूसरा है vector[1], आदि)

  1. संकेतन *(array + i) पूरी तरह से खराब है। कोड को अस्पष्ट करने के अलावा, कोई भी इसका उपयोग नहीं करता है। सही संकेतन array[i] है, और आपको पॉइंटर अंकगणित का उपयोग करने से बचना चाहिए जब तक कि आपको पॉइंटर्स और सरणियों के बीच अंतर का स्पष्ट विचार न हो।

  2. आप निम्नलिखित संकेतन के साथ बहुआयामी सरणियों का उपयोग कर सकते हैं:

    • एक द्विआयामी सरणी घोषित करने के लिए, उदा। a 2 पंक्तियाँ बटा तीन कॉलम सरणी, जिसका आप उपयोग करते हैं:
int A[2][3];
* You can access its elements (remember, zero based) as `A[0][0]`...`A[0][2]`, `A[1][0]`...`A[1][2]` and stop... no more elements in your array.

आइए देखें कि इस तरह के दो सरणियों को कैसे आरंभ और जोड़ना है:


#include <stdio.h>

/* declaration and initialization of both matrices A and B */
double A[2][3] = { { 0.0, 1.3, 3.14 }, { 5.6, 4.2, 3.8 } },
       B[2][3] = { {53.0, 42.8, 90.0}, { 2.718, 3.16, 1.4142135} };

/* the following function prints a matrix (of 2 rows by 3 columns) of 
 * name 'name' */
void
print_matrix(char *name, double M[2][3])
{
    printf("Matrix %s:\n", name);
    int row, col;
    for (row = 0; row < 2; row = row + 1) {
        for (col = 0; col < 3; col = col + 1) {
            if (col > 0) printf("\t");
            printf("%8.4f", M[row][col]);
        }
        printf("\n");
    }
    printf("\n");
}

int main()
{
    /* lets print matrix A */
    print_matrix("A", A);
    print_matrix("B", B); /* ... and B */

    double C[2][3]; /* declaration of matrix C */
    int r, c; /* row and column, for the loops */

    /* let's sum all the elements */
    for (r = 0; r < 2; r = r + 1) {
        for (c = 0; c < 3; c = c + 1) {
            C[r][c] = A[r][c] + B[r][c];
        }
    }

    /* and print the results */
    print_matrix("C", C);
    return 0;
}
0
Luis Colorado 20 मई 2020, 01:59

उदाहरण के लिए, ptr1 मेमोरी सिस्टम के ऑफ़सेट 0 को नीचे इंगित करता है, मैट्रिक्स आकार यदि 2x2

----- ----- ----- ----- ----- ----- --------------------
|    |     |     |     |     |      |
----- -----  ----- ----- ----- ----- -------------------
0                      16
^                       ^
|                       |
ptr1                   ptr2
<--readable/writable---><--------read-only/write-only---

इस मामले में, आप ऑफ़सेट 0 से 16 तक मान को पढ़ने और लिखने के लिए पॉइंटर को डीरेफ़रेंस कर सकते हैं। लेकिन समस्या यह है कि जब आप ptr2 द्वारा इंगित ऑफसेट 16 से मान को संशोधित करने का प्रयास करते हैं, तो वे पते केवल-पढ़ने के लिए या केवल-लिखने के लिए होते हैं, इसलिए सिस्टम आपको पढ़ने के लिए स्वीकार नहीं करता है या क्रमशः लिखें।

तो आपको ptr1 कम से कम 3*(row*col)*sizeof(int) (ptr1 से ptr3+row*col) के लिए आवंटित करना होगा।

int* ptr1 = malloc(3 * (row*col) * sizeof(int));
if(!ptr1) { // handle the error, because if you cannot allocate the memory, you do not need to do the rest of code.
   return -1; 
}

यदि आप करना चाहते हैं:

    for(int i=1;i<=(row*col);i++)
    {
        printf("%d ",(*(ptr3+i)));
        if(i%col == 0) printf("\n");
    }

आपने (3*row*col+1)*sizeof(int) आवंटित किया है या आप for लूप के इटरेटर को 0 से row*col-1 में बदल सकते हैं (मैं इस विकल्प की अनुशंसा करता हूं):

    for(int i=0;i< (row*col);i++)
    {
        printf("%d ",(*(ptr3+i)));
        if(i%col == 0) printf("\n");
    }

अपने कार्यक्रम के अंत में free(ptr1) को न भूलें।

0
Hitokiri 18 मई 2020, 18:32