vorbei typedef (Feste Größe) array als Wert

Ich bin schwer zu verstehen typedef Muster für arrays.

typedef char Char10[10];
void fun (Char10 a)  //not passing reference (interested in pass by value)
{
  if(typeid(Char10) == typeid(char*))
    throw 0;  //<--- never happens
}

int main ()
{
  char a[10];  fun(a);  //ok
  char b[11];  fun(b);  //why works ?
}

Warum die unterschiedlichen Größen der array als Wert akzeptiert fun() ? Sind char[10] und char[11] nicht verschiedene Arten ?

Bearbeiten: Für diejenigen, die sagt, es zerfällt zu Zeiger, siehe meinen bearbeiteten code. char[10] und char* scheint nicht zu passen.

Wenn Menschen sagen, dass "array zerfällt zu" pointer " Sie beziehen sich auf parameter a specifially. Also, in Ihrem if innerhalb der Funktion sollen Sie zu vergleichen typeid(a) == typeid(char*). Dies wird Ihnen zeigen, dass die Typen übereinstimmen. Vergleichen typeid(Char10) == typeid(char*) nicht alles zeigen. Diese sind in der Tat unterschiedliche Typen.

InformationsquelleAutor iammilind | 2011-05-17

arrays c++typedef

9

Sie sind verschiedene Arten, du hast Recht.

Es ist eine irreführende Eigenart von C++, die Sie gesehen werden können, die eine Funktion haben
```
void fun(char a[10])
```
Da Sie nicht das übergeben von arrays per Wert, und C++ ist dumm, das ist eigentlich die Funktion
```
void fun(char* a)
```
Und, natürlich, die beiden Eingänge abbauen glücklich zu char*.

Schön wäre es, wenn C++ nicht lassen Sie sogar so tun, um zu akzeptieren ein array als Wert, aber es ist dumm, in dieser Weise.. geerbt von C.
- Und IIRC war es mehr oder weniger geerbt von BCPL (oder eingeführt wurde, für irgendeine Art von Kompatibilität mit es).
- Ich glaub es kann nicht fun(char*), weil Empfangs-array per Referenz erlaubt es nur char[10] und Irrtümer für char[11].
- es gibt nichts, mit verweisen dort. Falls Sie haben eine Funktion void f(int(&)[3]); können Sie nicht einen Zeiger übergeben, das ist wahr. Aber in diesem Fall, Sie können.
- Empfangen von arrays von Referenz ist ein komplett anderer Kessel der Fische.
- Ja, vielleicht 🙂
- als 1. zu identifizieren. Es nahm mir Zeit zu verstehen, durch die anderen Antworten obwohl.
InformationsquelleAutor Lightness Races with Monica
22

In beiden Fällen werden die arrays, die Zerfall auf den Zeiger-Typ, und Ihre Funktion ist eigentlich dies:
```
void fun (char *a); 
```
Deshalb ist seine Arbeit.

Möchte ich betonen, dass void fun(char*) ist genau das gleiche wie void fun(char[10]). Die 10 macht keinen Unterschied. In der Tat 10 ist so unwichtig und nutzlos, die kann man auch weglassen, es komplett als:
```
void fun (char a[]); //exactly same as `char*` or `char[10]`.
```
Das bedeutet, alle die folgenden Deklarationen sind genau gleiche:
```
void fun(char a[10]);   
void fun(char a[]);  //10 is unimportant in the above declaration
void fun(char *a);   //same as above two declarations!
```
Hoffe, dass klärt Ihre Zweifel.

Jedoch, wenn Sie dies schreiben:
```
void fun (Char10 & a) ; //note &
```
dann tatsächlich dieses:
```
void fun (char (&a)[10]) ; //equivalent!
```
Dann fun(b) würde nicht kompilieren, wie jetzt fun NUR akzeptieren array von GENAU der Größe 10. Und das array wird nicht Zerfall zu Zeiger, es wird weitergegeben, indem Referenz.
```
char a[10], b[11];
char *c=new char[10];
fun(a); //okay
fun(b); //error - type mismatch due to size of the array
fun(c); //error - type mismatch due to c being pointer.
```
- Ich weiß, deshalb habe ich ausdrücklich erwähnt, "nicht erhalten, Verweis". Ich wollte wissen, warum pass-by-value funktioniert nicht. Siehe mein editierten post.
- Siehe meine Antwort wieder!
- Nicht, dass das, was er schrieb, als die erste version? Ihre Funktion ist eigentlich void fun(char*).
InformationsquelleAutor Nawaz
4

Char10 und char* gibt ja verschiedene Arten..

Versuchen
```
if(typeid(a) == typeid(char*))
    throw 0;  //happens
```
Online-demo

P. S:

Die folgenden Deklarationen sind äquivalent
```
void fun(Char10 a);
void fun(char a[]);
void fun(char *a);
```
InformationsquelleAutor Prasoon Saurav
2

Wenn erhalten Sie einen array-parameter, die der compiler versteht Sie als ein Zeiger auf das array das erste element. Da gibt es keinen Unterschied zwischen arrays unterschiedlicher Größe zur Laufzeit. Das ist, warum Sie müssen wissen, die Größe, die Sie arbeiten mit, um zu vermeiden, den Zugriff auf Speicher, der gehört nicht zu Ihrem Programm..

InformationsquelleAutor Gabriel
2

Für Ihre edit: die Typen per se sind unterschiedlich, aber in C++ kann nicht übergeben werden ein array-Wert als argument an eine Funktion, und die array-Typ zerfällt der entsprechende Zeiger geben, wenn Sie es als eine Funktion argument.
```
#include <iostream>
#include <typeinfo>

using namespace std;

typedef char Char10[10];
void fun (Char10 a) //<-- actually Char10 here is read as char *
{
    Char10 test;
    cout<<(typeid(Char10) == typeid(char*))<<'\n'
        <<(typeid(Char10) == typeid(test))<<'\n'
        <<(typeid(char *) == typeid(a))<<endl;
}

int main ()
{
  char b[11];  fun(b);  //why works ?
}
```
Diese Ausgänge
```
0
1
1
```
Weil
- char * und char[10] sind verschiedene Arten;
- test ist ein char[10]
- a ist eigentlich ein char *, weil in Funktionsdeklarationen die array Deklaration zerfällt der entsprechende Zeiger-Deklaration.
Dies ist eine dumme Sache, die hier aus historischen Gründen, aber wir sind dabei geblieben.

Gefunden in der standard: bei §8.3.5 ¶3:

Nach der Bestimmung der Art der einzelnen parameter, alle parameter vom Typ "array von T" oder " - Funktion zurückgeben T" angepasst werden "Zeiger auf T" oder "Zeiger auf Funktion, Rückgabe T", bzw.
- danke. Beachten Sie, stattdessen, dass die Verpackung des Arrays innerhalb einer struct/class lassen Sie er als Wert übergeben werden (Dank der Tatsache, dass structs kann durch Wert übergeben werden, und der default-Konstruktor Verhalten zu kopieren-Mitglieder). Dies ist, wie die neue std::array Feste Größe-low-overhead-container funktioniert.
InformationsquelleAutor Matteo Italia
1

Können Sie akzeptiert jedoch eine Referenz auf ein array der richtigen Größe, an welcher Stelle der compiler wird - Objekt zu.
- Ich weiß, deshalb habe ich ausdrücklich erwähnt, "nicht erhalten, Verweis". Ich wollte wissen, warum pass-by-value funktioniert nicht.
InformationsquelleAutor Puppy
1

Können Sie nicht übergeben, array nach Wert weder in C noch in C++. Arrays in C/C++ sind nicht kopierbar, also unabhängig davon, was Sie tun, werden Sie nie erreichen "pass by value" Semantik mit array-Typ.

Sieht es aus wie Sie hofften, dass das verstecken der array-Typ hinter einem typedef-name wird lassen Sie diese Einschränkung umgehen. Es nicht. Ihre
```
void fun(Char10 a)
```
Erklärung entspricht
```
void fun(char a[10])
```
Erklärung, welche wiederum äquivalent zu
```
void fun(char a[])
```
und
```
void fun(char *a)
```
So, Ihr a parameter hat den Typ Zeiger. Wenn Sie ein array übergeben, wie das
```
char a[10]; fun(a); 
```
sind Sie einfach nur die übergabe eines char * Zeiger auf das erste element des Arrays. Die Größe des Arrays spielt keine Rolle, die ist, warum Sie sind in der Lage, arrays zu übergeben, in verschiedenen Größen mit dieser Methode.

Innerhalb der fun Funktion, wenn Sie möchten, analysieren Sie die Art des Parameters a sollen Sie gelten typeid zu a
```
if(typeid(a) == typeid(char*))
  throw 0;
```
Dies wird Ihnen zeigen, dass die Typen übereinstimmen. Warum Sie sich bewerben die typeid direkt zu Char10 und was Sie erwarten, zu leiten daraus ist mir nicht klar. Array-Typen decay Zeiger-Typen in der Funktion parameter-Erklärung, aber Sie nicht Verfall zu Zeiger-Typen in typed - operator, was bedeutet, dass Ihre version von if ist absolut nichts was passiert in der parameter-Deklaration.
- warum typeids sind, die nicht zusammenpassen ?
- Da Char10 und char* sind verschiedene Arten. Versuchen Vergleich Art der a und char* wie ich erwähnt habe in meinem Beitrag.
- Typen passende. Siehe den zweiten Teil meiner Antwort. Was Sie vergleichen in Ihrem ursprünglichen code hat keinen Bezug auf die Frage auf der hand. Wenn Sie möchten, um zu sehen, ob die Typen übereinstimmen, Sie sollen vergleichen typeid(a).
- Ich sehe nicht, warum diese Antwort verdient ein downvote. Sie wiederholt einige der Informationen aus den anderen Antworten, aber es sieht aus, wie Sie Tippen wohl zur gleichen Zeit wie Sie trotzdem. Die Informationen, die Sie gab, durchaus gültig ist, obwohl...
InformationsquelleAutor AnT
1
```
struct char10 {
    char c[10];
};

int foo(char10 param){
...
```
Können Sie emulieren vorbei fixed-size-arrays durch Wert wie diese.

InformationsquelleAutor Jeremy

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.