সি ব্যবহার করে একটি অ্যারে ফিরছে

Question

আমি সি-তে তুলনামূলকভাবে নতুন এবং অ্যারে নিয়ে কাজ করার পদ্ধতিগুলির জন্য আমার কিছুটা সহায়তা প্রয়োজন। জাভা প্রোগ্রামিং থেকে আসা, আমি বলতে সক্ষম হতে অভ্যস্তint [] method() অ্যারে ফেরত দেওয়ার । তবে, আমি জানতে পেরেছি যে সি দিয়ে আপনি যখন ফিরিয়ে দেন তখন আপনাকে অ্যারেগুলির জন্য পয়েন্টার ব্যবহার করতে হবে। নতুন প্রোগ্রামার হওয়ার কারণে, আমি যে অনেক ফোরাম দেখেছি, তা আমি সত্যিই বুঝতে পারছি না।

মূলত, আমি এমন একটি পদ্ধতি লেখার চেষ্টা করছি যা সি-তে একটি চর অ্যারে প্রদান করে I এটি পূর্ববর্তী অ্যারে থেকে একটি নতুন অ্যারে তৈরি করবে এবং এতে একটি পয়েন্টার ফিরিয়ে দেবে। এটি শুরু করার পদ্ধতি এবং পয়েন্টারটি একবার অ্যারে থেকে বেরিয়ে যাওয়ার পরে কীভাবে পড়তে হবে তার জন্য আমার কিছুটা সহায়তা দরকার। এটি ব্যাখ্যা করার জন্য যে কোনও সহায়তা প্রশংসিত হয়।

অ্যারে রিটার্নিং ফাংশনের জন্য প্রস্তাবিত কোড ফর্ম্যাট

char *returnArray(char array []){
 char returned [10];
 //methods to pull values from array, interpret them, and then create new array
 return &(returned[0]); //is this correct?
} 

ফাংশন কলার

int main(){
 int i=0;
 char array []={1,0,0,0,0,1,1};
 char arrayCount=0;
 char* returnedArray = returnArray(&arrayCount); ///is this correct?
 for (i=0; i<10;i++)
  printf(%d, ",", returnedArray[i]);  //is this correctly formatted?
}

আমার সি সংকলক এই মুহুর্তে কাজ করছে না বলে আমি এখনও এটি পরীক্ষা করি নি তবে আমি এটি বের করতে চাই

Comments

আপনার কোডের নমুনায় উল্লিখিত হিসাবে কি রিটার্ন অ্যারে একটি পরিচিত আকারের? উত্তরে উল্লিখিত স্ট্যাক ইস্যুগুলি ছাড়া আমি দেখতে পাচ্ছি কেবলমাত্র অন্য গোটচা হ'ল যদি আপনার রিটার্ন অ্যারেটি সীমিত আকার হয় তবে সিটিতে পয়েন্টার / অ্যারেগুলি যেভাবে কাজ করে তা আপনি জানেন না এটি কতটা বড়।

— আজিজফ্রিওয়ার্ল্ড

হ্যাঁ, আমি সর্বদা অসম্পূর্ণ অ্যারের আকার জানি। ইনপুট এবং আউটপুট অ্যারের অভিরুজের আকার।

— ব্যবহারকারী1506919

সি ভাষার বিকাশ * - bell-labs.com/usr/dmr/www/chist.html

— x4444

Answer 1

আপনি সি তে ফাংশন থেকে অ্যারেগুলি ফিরতে পারবেন না আপনি এটিও করতে পারবেন না (হওয়া উচিত নয়):

char *returnArray(char array []){
 char returned [10];
 //methods to pull values from array, interpret them, and then create new array
 return &(returned[0]); //is this correct?
} 

returned স্বয়ংক্রিয় স্টোরেজ সময়কাল দিয়ে তৈরি করা হয় এবং এর উল্লেখগুলি অবৈধ হয়ে যাবে যখন এটি তার ঘোষণার সুযোগটি ছেড়ে দেয়, অর্থাত্ যখন ফাংশনটি ফিরে আসে।

আপনাকে ক্রিয়াকলাপের ভিতরে মেমরিটি গতিশীলভাবে বরাদ্দ করতে হবে বা কলার সরবরাহকারী একটি পূর্বনির্ধারিত বাফার পূরণ করতে হবে।

বিকল্প 1:

গতিশীলভাবে ফাংশনটির ভিতরে মেমরি বরাদ্দ করুন (কল্যাণকর জন্য দায়ী কলার ret)

char *foo(int count) {
    char *ret = malloc(count);
    if(!ret)
        return NULL;

    for(int i = 0; i < count; ++i) 
        ret[i] = i;

    return ret;
}

এটি যেমন কল:

int main() {
    char *p = foo(10);
    if(p) {
        // do stuff with p
        free(p);
    }

    return 0;
}

বিকল্প 2:

কলারের দ্বারা সরবরাহিত একটি পূর্বনির্ধারিত বাফার পূরণ করুন (কলার বরাদ্দ করে bufএবং কার্যক্রমে পাস করে)

void foo(char *buf, int count) {
    for(int i = 0; i < count; ++i)
        buf[i] = i;
}

এবং এটি যেমন কল:

int main() {
    char arr[10] = {0};
    foo(arr, 10);
    // No need to deallocate because we allocated 
    // arr with automatic storage duration.
    // If we had dynamically allocated it
    // (i.e. malloc or some variant) then we 
    // would need to call free(arr)
}

Comments

বিকল্প 3: (একটি স্ট্যাটিক অ্যারে)

— মূয়িপ

@ মূওইয়িপ: হ্যাঁ, জিনিসগুলি সরল রাখার জন্য আমি উদ্দেশ্যমূলকভাবে এটি ছেড়ে দিয়েছি, তবে হ্যাঁ, আপনি ফাংশনের মধ্যে থেকে ঘোষিত স্থিতিশীল ডেটাতে একটি পয়েন্টার ফিরিয়ে দিতে পারেন।

— এড এস

@ ব্যবহারকারী1506919: আমি প্রকৃতপক্ষে বিকল্প 2 পছন্দ করবো কারণ এটি স্পষ্ট যে মেমরি কে বরাদ্দ করে এবং হ্রাস করে, তবে আমি আপনার জন্য একটি উদাহরণ যুক্ত করব।

— এড এস

বিকল্প 4: একটি স্ট্রাক্ট ফিরুন যাতে স্থির আকারের অ্যারে থাকে।

— টড লেহম্যান

বিকল্প 5: একটি ইউনিয়ন ফিরিয়ে দিন যাতে স্থির আকারের অ্যারে রয়েছে।

— sqr163

Answer 2

সি এর অ্যারেগুলির চিকিত্সা জাভা থেকে খুব আলাদা এবং আপনাকে সেই অনুযায়ী আপনার চিন্তাভাবনা সামঞ্জস্য করতে হবে। সি-তে অ্যারেগুলি প্রথম-শ্রেণীর অবজেক্ট নয় (যা একটি অ্যারের এক্সপ্রেশনটি বেশিরভাগ প্রসঙ্গে এটি "অ্যারে-নেস" ধরে রাখে না)। সি-তে, "এন-এলিমেন্ট অ্যারের অফ T" টাইপের একটি এক্সপ্রেশন স্পষ্টভাবে রূপান্তরিত হবে ("ক্ষয়") টাইপটিকে "পয়েন্টার টু T" টাইপ করে, অ্যারে এক্সপ্রেশনটি ব্যতীত sizeofবা ইউনারি বাদে ব্যতীত& অপারেটরের বা যদি অ্যারে এক্সপ্রেশন হ'ল স্ট্রিং আক্ষরিক যা একটি ঘোষণায় অন্য অ্যারে শুরু করার জন্য ব্যবহৃত হয়।

অন্যান্য জিনিসের মধ্যে, এর অর্থ হ'ল আপনি কোনও ফাংশনে অ্যারে এক্সপ্রেশনটি পাস করতে পারবেন না এবং এটি অ্যারের ধরণের হিসাবে পেয়েছেন ; ফাংশনটি আসলে একটি পয়েন্টার টাইপ পায়:

void foo(char *a, size_t asize)
{
  // do something with a
}

int bar(void)
{
  char str[6] = "Hello";
  foo(str, sizeof str);
}

কলটিতে foo, strভাবটি টাইপ থেকে রূপান্তরিত char [6]হয় char *, এজন্য প্রথম প্যারামিটার পরিবর্তে fooঘোষিত char *aহয় char a[6]। ইন sizeof str, যেহেতু অ্যারে এক্সপ্রেশনটি sizeofঅপারেটরের অপারেন্ড , এটি কোনও পয়েন্টার টাইপে রূপান্তরিত হয় না, তাই আপনি অ্যারেতে বাইট সংখ্যা (6) পান।

আপনি যদি সত্যিই আগ্রহী হন তবে আপনি ডেনিস রিচির সি ভাষার ভাষার বিকাশ পড়তে পারেন এই চিকিত্সাটি কোথা থেকে এসেছে তা বুঝতে আপনি ।

আপশটটি হ'ল ফাংশনগুলি অ্যারের ধরণগুলি ফেরত দিতে পারে না, যা ঠিক আছে কারণ অ্যারে এক্সপ্রেশনগুলি কোনও কার্যনির্বাহীতার লক্ষ্য হতে পারে না।

সবচেয়ে নিরাপদ পদ্ধতি হ'ল কলারের পক্ষে অ্যারে সংজ্ঞায়িত করা এবং তার ঠিকানা এবং আকারটি যে ফাংশনে এটি লেখার কথা ছিল তা পাস করুন:

void returnArray(const char *srcArray, size_t srcSize, char *dstArray, char dstSize)
{
  ...
  dstArray[i] = some_value_derived_from(srcArray[i]);
  ...
}

int main(void)
{
  char src[] = "This is a test";
  char dst[sizeof src];
  ...
  returnArray(src, sizeof src, dst, sizeof dst);
  ...
}

আর একটি পদ্ধতি হ'ল অ্যারেটিকে গতিশীলভাবে বরাদ্দ করা এবং পয়েন্টার এবং আকারটি ফেরত দেওয়া:

char *returnArray(const char *srcArray, size_t srcSize, size_t *dstSize)
{
  char *dstArray = malloc(srcSize);
  if (dstArray)
  {
    *dstSize = srcSize;
    ...
  }
  return dstArray;
}

int main(void)
{
  char src[] = "This is a test";
  char *dst;
  size_t dstSize;

  dst = returnArray(src, sizeof src, &dstSize);
  ...
  free(dst);
  ...
}

এই ক্ষেত্রে, কলারটি freeলাইব্রেরির ক্রিয়াকলাপের সাথে অ্যারেটিকে কমিয়ে দেওয়ার জন্য দায়বদ্ধ ।

নোট করুন যে dstউপরের কোডটিতে একটি সরল পয়েন্টার char, বিন্যাসের বিন্যাস নয় char। সি এর পয়েন্টার এবং অ্যারের শব্দার্থবিজ্ঞান এমন যে আপনি []অ্যারে টাইপ বা পয়েন্টার টাইপের একটি এক্সপ্রেশনতে সাবস্ক্রিপ্ট অপারেটর প্রয়োগ করতে পারেন ; উভয়ই src[i]এবং অ্যারের 'তম উপাদানটি dst[i]অ্যাক্সেস করবে i(যদিও শুধুমাত্র onlysrc অ্যারে টাইপ রয়েছে)।

আপনি একটি এন-উপাদান অ্যারের একটি পয়েন্টার ঘোষণা করতে পারেনT এবং অনুরূপ কিছু করতে পারেন:

char (*returnArray(const char *srcArr, size_t srcSize))[SOME_SIZE]
{
  char (*dstArr)[SOME_SIZE] = malloc(sizeof *dstArr);
  if (dstArr)
  {
    ...
    (*dstArr)[i] = ...;
    ...
  }
  return dstArr;
}

int main(void)
{
  char src[] = "This is a test";
  char (*dst)[SOME_SIZE];
  ...
  dst = returnArray(src, sizeof src);
  ...
  printf("%c", (*dst)[j]);
  ...
}

উপরের সাথে কয়েকটি ত্রুটি। প্রথমত, সি এর পুরানো সংস্করণগুলি SOME_SIZEএকটি সংকলন-সময় ধ্রুবক হওয়ার প্রত্যাশা করে, যার অর্থ এই ফাংশনটি কেবলমাত্র একটি অ্যারের আকারের সাথে কাজ করবে। দ্বিতীয়ত, সাবস্ক্রিপ্ট প্রয়োগ করার আগে আপনাকে পয়েন্টারটি অবলম্বন করতে হবে, যা কোডকে বিশৃঙ্খলা করে। আপনি বহুমাত্রিক অ্যারে নিয়ে কাজ করার সময় অ্যারেগুলিতে পয়েন্টারগুলি আরও ভাল কাজ করে।

Comments

"সি এর বিকাশ" এর সাথে আপনার লিঙ্কটি ভেঙে গেছে ... দেখে মনে হচ্ছে এটি আমাদের এখানে দিকনির্দেশনা দেয়

— ডাঃ কিউসো

@ কুন্ডর: যা আদায় করা barহয় তা বিন্দু নয়, অ্যারে নয়। একটি ফাংশন প্যারামিটার ঘোষণা প্রসঙ্গে, T a[N]এবং T a[]উভয় হিসাবে বিবেচিত হয় T *a।

— জন বোদে

@ জনবোড: আপনি ঠিক বলেছেন! কিছু কারণে আমি ভেবেছিলাম স্থির আকারের অ্যারেগুলি স্ট্যাকের উপর দিয়ে গেছে। আমি একটি উপলক্ষের কথা স্মরণ করি, বহু বছর আগে, যখন আমি পেলাম যে একটি অ্যারের আকার প্যারামিটার স্বাক্ষরে নির্দিষ্ট করতে হয়েছিল তবে আমি অবশ্যই বিভ্রান্ত হয়ে পড়েছি।

— নিক মাত্তিও

@ জনবোড, দ্বিতীয় কোডের প্রথম লাইনে: void returnArray(const char *srcArray, size_t srcSize, char *dstArray, char dstSize)শেষ প্যারামিটারটি size_tটাইপ না হওয়া উচিত char।

— সেফি

Answer 3

আমি বলছি না যে এটি প্রদত্ত সমস্যার সর্বোত্তম সমাধান বা পছন্দসই সমাধান। যাইহোক, এটি মনে রাখা কার্যকর হতে পারে যে ফাংশনগুলি স্ট্রটগুলি ফিরে আসতে পারে। যদিও ফাংশন অ্যারে ফিরিয়ে দিতে পারে না, অ্যারে স্ট্র্যাপগুলিতে আবৃত হতে পারে এবং ফাংশনটি স্ট্রাক্টটিকে এটির সাথে বহন করে ফিরিয়ে আনতে পারে। এটি স্থির দৈর্ঘ্যের অ্যারেগুলির জন্য কাজ করে।

    #include <stdio.h>
    #include <stdlib.h>
    #include <string.h>

    typedef
    struct 
    {
        char v[10];
    } CHAR_ARRAY;



    CHAR_ARRAY returnArray(CHAR_ARRAY array_in, int size)
    {
        CHAR_ARRAY returned;

        /*
        . . . methods to pull values from array, interpret them, and then create new array
        */

        for (int i = 0;  i < size; i++ )
            returned.v[i] = array_in.v[i] + 1;

        return returned; // Works!
    } 




    int main(int argc, char * argv[])
    {
        CHAR_ARRAY array = {1,0,0,0,0,1,1};

        char arrayCount = 7;

        CHAR_ARRAY returnedArray = returnArray(array, arrayCount); 

        for (int i = 0; i < arrayCount; i++)
            printf("%d, ", returnedArray.v[i]);  //is this correctly formatted?

        getchar();
        return 0;
    }

আমি এই কৌশলটির শক্তি এবং দুর্বলতাগুলির বিষয়ে মন্তব্যগুলি আমন্ত্রণ করি। আমি এটা করতে বিরক্ত করিনি।

Comments

কেন এটি গ্রহণযোগ্য উত্তর নয় তা অস্পষ্ট। কোনও অ্যারেতে কোনও পয়েন্টারটি ফেরানো সম্ভব কিনা তা প্রশ্ন ছিল না।

— ফ্রাঙ্ক পাক

CHAR_ARRAY returnedগাদা জন্য স্মৃতি বরাদ্দ করা হয়? এটা অবশ্যই করতে পারেন না স্ট্যাক (এর সময় স্ট্যাক ফ্রেম উপর returnArray()ঠিক আছে?

— মিন Tran

Answer 4

কিভাবে এই সুস্বাদু মন্দ বাস্তবায়ন সম্পর্কে?

array.h

#define IMPORT_ARRAY(TYPE)    \
    \
struct TYPE##Array {    \
    TYPE* contents;    \
    size_t size;    \
};    \
    \
struct TYPE##Array new_##TYPE##Array() {    \
    struct TYPE##Array a;    \
    a.contents = NULL;    \
    a.size = 0;    \
    return a;    \
}    \
    \
void array_add(struct TYPE##Array* o, TYPE value) {    \
    TYPE* a = malloc((o->size + 1) * sizeof(TYPE));    \
    TYPE i;    \
    for(i = 0; i < o->size; ++i) {    \
        a[i] = o->contents[i];    \
    }    \
    ++(o->size);    \
    a[o->size - 1] = value;    \
    free(o->contents);    \
    o->contents = a;    \
}    \
void array_destroy(struct TYPE##Array* o) {    \
    free(o->contents);    \
}    \
TYPE* array_begin(struct TYPE##Array* o) {    \
    return o->contents;    \
}    \
TYPE* array_end(struct TYPE##Array* o) {    \
    return o->contents + o->size;    \
}

main.c

#include <stdlib.h>
#include "array.h"

IMPORT_ARRAY(int);

struct intArray return_an_array() {
    struct intArray a;
    a = new_intArray();
    array_add(&a, 1);
    array_add(&a, 2);
    array_add(&a, 3);
    return a;
}

int main() {
    struct intArray a;
    int* it;
    int* begin;
    int* end;
    a = return_an_array();
    begin = array_begin(&a);
    end = array_end(&a);
    for(it = begin; it != end; ++it) {
        printf("%d ", *it);
    }
    array_destroy(&a);
    getchar();
    return 0;
}

Comments

এটি আমার কৌতূহল উত্থাপন করার জন্য শয়তানের পক্ষে যথেষ্ট সুস্বাদু। আপনি সেখানে কী করেছেন সে সম্পর্কে আপনি আরও কিছুটা ব্যাখ্যা করতে পারেন বা আপনি যে সুস্বাদু স্বাদে ডেকে পাঠাচ্ছেন তার পরামর্শ দেওয়ার জন্য? আগাম ধন্যবাদ.

— আনহেলিগ

@ আনহেলিগ - নোট করুন যে এতে সম্ভাব্য বাগ রয়েছে, এটি কেবল ধারণার প্রমাণ ছিল a বলেছিল, কৌশলটি structঅ্যারের ধারক / অবজেক্ট হিসাবে ফিরে আসছে is এটি একটি সি ++ স্টেড :: ভেক্টরের মতো ভাবেন। প্রিপ্রসেসর এটির intসংস্করণটি প্রসারিত করবে struct intArray { int* contents; int size; };।

— পাইরোস্প্যাড

আমি পদ্ধতির পছন্দ। প্রো: এটি জেনেরিক সমাধান; বিপরীতে: মেমরি নিবিড় সমাধান। কাঁচা মাপের ভেক্টরগুলির জন্য অনুকূল নয়। যাইহোক এটি ইনিটাল আকার বরাদ্দ দিয়ে আপগ্রেড করা যেতে পারে। আমি নির্দিষ্ট বরাদ্দ চেক যোগ করতে হবে। :) দিয়ে শুরু করার জন্য খুব ভাল প্রস্তাব

— urkon

অবজেক্ট ওরিয়েন্টেড-এস্ক প্রিপোসেসেসিং মিক্স-ম্যাস। আমি এটা পছন্দ করি.

— জ্যাক গিফিন

Answer 5

আপনার ক্ষেত্রে, আপনি স্ট্যাকের উপর একটি অ্যারে তৈরি করছেন এবং একবার আপনি ফাংশনটির সুযোগটি ছেড়ে দিলে অ্যারেটি হ্রাস করা হবে। পরিবর্তে, গতিশীলভাবে বরাদ্দ করা অ্যারে তৈরি করুন এবং এতে একটি পয়েন্টার ফিরিয়ে দিন।

char * returnArray(char *arr, int size) {
    char *new_arr = malloc(sizeof(char) * size);
    for(int i = 0; i < size; ++i) {
        new_arr[i] = arr[i];
    }
    return new_arr;
}

int main() {

    char arr[7]= {1,0,0,0,0,1,1};
    char *new_arr = returnArray(arr, 7);

    // don't forget to free the memory after you're done with the array
    free(new_arr);

}

Comments

newসি তে কোনও অপারেটর নেই এটি সি ++।

— এরিক পোস্টপিসিল

এবং sizeof(char)গ্যারান্টিযুক্ত 1, তাই এই ক্ষেত্রে আপনি যে বিট থেকে বাদ দিতে পারেন malloc।

— এড এস

ঠিক আছে তাই আমি যদি নতুন অ্যারের বিষয়বস্তু মুদ্রণ করতে চাইতাম তবে আমি কি কেবল আমার 'প্রিন্টফ' স্টেটমেন্টটি করতে পারি, তবে 'রিটার্নআর'এর সাথে' আর্ট 'দিয়ে প্রতিস্থাপন করতে পারি?

— ব্যবহারকারী1506919

আপনি ফাংশনটি সঠিকভাবে কল করছেন না (কেবলমাত্র একটি যুক্তি যখন স্বাক্ষরের দুটি প্রয়োজন)।

— এড এস

আপনি ভিতরে যাচ্ছেন &arr। আপনি arrএকটি হতে চান char *এবং এটি ব্যবহার করে পাস করুন arr।

— ক্রিস

Answer 6

আপনি এখানে প্রতিবেদন করা অন্যান্য উত্তরের মতো হিপ মেমোরি ( malloc () অনুরোধের মাধ্যমে ) ব্যবহার করে এটি করতে পারেন তবে আপনাকে সর্বদা আপনার ফাংশনটি কল করার সময় অবশ্যই মেমরিটি ( ফ্রি () ফাংশন ব্যবহার করতে হবে) পরিচালনা করতে হবে । আপনি এটি একটি স্ট্যাটিক অ্যারে দিয়েও করতে পারেন:

char* returnArrayPointer() 
{
static char array[SIZE];

// do something in your array here

return array; 
}

মেমরি পরিচালনা সম্পর্কে চিন্তা না করে আপনি এটিকে ব্যবহার করতে পারেন।

int main() 
{
char* myArray = returnArrayPointer();
/* use your array here */
/* don't worry to free memory here */
}

এই উদাহরণে আপনাকে অ্যারে লাইফের লাইফের জন্য অ্যাপ্লিকেশন স্থির করতে অ্যারে সংজ্ঞাতে স্থির কীওয়ার্ডটি ব্যবহার করতে হবে, সুতরাং এটি রিটার্নের বিবৃতি দেওয়ার পরে ধ্বংস হবে না। অবশ্যই, আপনি পুরো অ্যাপ্লিকেশন জীবনের জন্য আপনার স্মৃতিতে সাইজ বাইট দখল করেন, তাই এটি সঠিকভাবে আকার করুন!

Answer 7

আপনার পদ্ধতিটি স্থানীয় স্ট্যাক ভেরিয়েবল ফিরিয়ে দেবে যা খারাপভাবে ব্যর্থ হবে। একটি অ্যারে ফিরিয়ে আনার জন্য, ফাংশনের বাইরে একটি তৈরি করুন, ঠিকানায় এটি ফাংশনে প্রবেশ করুন, তারপরে এটি পরিবর্তন করুন, বা গাদাতে একটি অ্যারে তৈরি করুন এবং সেই পরিবর্তনশীলটি ফিরিয়ে দিন। উভয়ই কাজ করবে, তবে প্রথমটিকে সঠিকভাবে কাজ করতে কোনও গতিশীল মেমরি বরাদ্দ লাগবে না।

void returnArray(int size, char *retArray)
{
  // work directly with retArray or memcpy into it from elsewhere like
  // memcpy(retArray, localArray, size); 
}

#define ARRAY_SIZE 20

int main(void)
{
  char foo[ARRAY_SIZE];
  returnArray(ARRAY_SIZE, foo);
}

Answer 8

আপনি এই জাতীয় কোড ব্যবহার করতে পারেন:

char *MyFunction(some arguments...)
{
    char *pointer = malloc(size for the new array);
    if (!pointer)
        An error occurred, abort or do something about the error.
    return pointer; // Return address of memory to the caller.
}

আপনি যখন এটি করেন, ঠিকানাটি বিনামূল্যে পাস করে মেমরিটি পরে ছেড়ে দেওয়া উচিত।

অন্যান্য বিকল্প আছে। একটি রুটিন একটি অ্যারেতে পয়েন্টার ফিরে আসতে পারে (বা অ্যারের অংশ) যা কিছু বিদ্যমান কাঠামোর অংশ। কলার একটি অ্যারে পাস করতে পারে এবং রুটিন কেবল নতুন অ্যারের জন্য জায়গা বরাদ্দ না করে কেবল অ্যারেতে লিখে দেয়।