අර්ථ දැක්වීමක් සහ ප්‍රකාශයක් අතර වෙනස කුමක්ද?

871

දෙකෙහිම අරුත මා මග හැරේ.

c  declaration  terminology  definition  c++-faq 
— මැකීක්
source
91
As ලස්: සත්‍ය නොවේ. අර්ථ දැක්වීම යන දෙකම අර්ථ දක්වයි ;-)
— ස්ටීව් ජෙසොප්
13
අවංකවම, මට ඉගෙනීමට බොහෝ කරදර ඇති අතර එය නම් පැහැදිලිව පෙනෙන්නට නැත. අර්ථයන් සමඟ සම්බන්ධ වීමට කුමන නම් පමණක් දැයි මට තේරුමක් නැත.
— ඩේවිඩ් තෝර්න්ලි
1
අපි මේ ගැන සවිස්තරාත්මකව විස්තර කර ඇත්තෙමු
— dmckee --- හිටපු උපපරිපාලක පූස් පැටවා
6
කෙසේ වෙතත්, මෙය අනුපිටපත් ප්‍රශ්නයක් නොවේ, මන්ද මෙය සී / සී ++ ගැන විමසන අතර අනෙක් ප්‍රශ්නය සියලු භාෂාවන් ගැන හෝ පොදුවේ කිසිවක් අසන්නේ නැත. එයට ඇත්තේ අනුපිටපත් පිළිතුරු පමණි (අනෙක් ප්‍රශ්නයේදී, සමහර පිළිතුරු සී සහ / හෝ සී ++ හැර අනෙක් සියලුම භාෂාවන් නොසලකා හැරීමට තෝරාගෙන ඇත).
— ස්ටීව් ජෙසොප්
5
Av ඩේවිඩ්ටෝර්න්ලි මම මෙම උපක්‍රමය භාවිතා කරමි: අර්ථ දැක්වීමක් දී ඇති විචල්‍යයක් හෝ ශ්‍රිතයක් පිළිබඳ සියුම් විස්තරයක් ලබා දෙයි . මෙය මතක තබා ගැනීම සඳහා, "අර්ථ දැක්වීම" යන වචනයේ මැද "සිහින්" යන වචනයට සමානකමක් ඇති බව මට මතකය. :)
— මාකෝ ලියෝග්‍රැන්ඩ්

Answers:

867

ඒ ප්රකාශය හඳුන්වනයක් හඳුන්වා දෙයි හා එහි වර්ගය විස්තර, එය වර්ගය, වස්තුව, හෝ කාර්යය විය. ප්‍රකාශයක් යනු සම්පාදකයාට එම හඳුනාගැනීමේ යොමු පිළිගැනීමට අවශ්‍ය දෙයයි . මේවා ප්‍රකාශන:

extern int bar;
extern int g(int, int);
double f(int, double); // extern can be omitted for function declarations
class foo; // no extern allowed for type declarations

ඒ අර්ථ දැක්වීම මෙම හඳුනාගැනීමේ ඇත්තටම instantiates / ක්රියාත්මක කරයි. ඒක මේ linker අවශ්ය දේ එම ආයතන වෙත සබැඳෙන පිටු යොමු කිරීම සඳහා. මේවා ඉහත ප්‍රකාශයන්ට අනුරූප වන නිර්වචන වේ:

int bar;
int g(int lhs, int rhs) {return lhs*rhs;}
double f(int i, double d) {return i+d;}
class foo {};

ප්‍රකාශයක් කරන ස්ථානයේ අර්ථ දැක්වීමක් භාවිතා කළ හැකිය.

ඔබට අවශ්‍ය සෑම විටම හඳුනාගැනීමක් ප්‍රකාශ කළ හැකිය . මේ අනුව, පහත දැක්වෙන්නේ සී සහ සී ++ වල නීත්‍යානුකූල ය:

double f(int, double);
double f(int, double);
extern double f(int, double); // the same as the two above
extern double f(int, double);

කෙසේ වෙතත්, එය හරියටම එක් වරක් අර්ථ දැක්විය යුතුය . කොතැනක හෝ ප්‍රකාශයට පත් කර ඇති සහ යොමු කරන ලද යමක් අර්ථ දැක්වීමට ඔබට අමතක වුවහොත්, සම්බන්ධකයට යොමු කිරීම් සම්බන්ධ කරන්නේ කුමක් දැයි නොදන්නා අතර නැතිවූ සංකේත ගැන පැමිණිලි කරයි. ඔබ එක් වරකට වඩා යමක් අර්ථ දක්වන්නේ නම්, අනුපිටපත් සම්බන්ධ කිරීමට කුමන නිර්වචන සම්බන්ධ කරන්නා නොදන්නා අතර අනුපිටපත් සංකේත ගැන පැමිණිලි කරයි.

C ++ හි පන්ති අර්ථ දැක්වීමට එදිරිව පන්ති ප්‍රකාශනය යනු කුමක්ද යන්න පිළිබඳ විවාදය දිගටම පවතින බැවින් (වෙනත් ප්‍රශ්නවලට පිළිතුරු සහ අදහස් දැක්වීමේදී), මම මෙහි C ++ ප්‍රමිතියෙන් උපුටා දැක්වීමක් කරමි. 3.1 / 2 දී, C ++ 03 පවසයි:

ප්‍රකාශයක් යනු අර්ථ දැක්වීමකි […] එය පන්ති නාම ප්‍රකාශයක් නොවේ නම් [...].

3.1 / 3 පසුව උදාහරණ කිහිපයක් ලබා දෙයි. ඒ අතර:

[උදාහරණයක්: [...]
struct S {int a; int b; }; // S, S :: a, සහ S :: b [...] යන්න අර්ථ දක්වයි
struct S; // එස්
උදාහරණයක් ලෙස

එය සාරාංශ කිරීම සඳහා: C ++ සම්මත සලකන struct x;වීමට ඉඩ ප්රකාශ හා struct x {};එය නිර්වචනය . (වෙනත් වචන වලින් කිවහොත්, "ඉදිරි ප්‍රකාශනය" වැරදි නාම ලේඛකයෙකි C ++ හි වෙනත් ආකාරයේ පන්ති ප්‍රකාශන නොමැති බැවින් .)

ඔහුගේ එක් පිළිතුරක සත්‍ය පරිච්ඡේදය සහ පදය හාරා ඇති ලිට්බ් (ජොහැන්නස් ෂෝබ්) ට ස්තූතියි .

— sbi
source
2
nowunknown: එක්කෝ ඔබේ සම්පාදකයා කැඩී ගොස් ඇති අතර ඔබ sbi කේතය වැරදි ලෙස පිටපත් කර ඇත. උදාහරණයක් ලෙස, N1124 හි 6.7.2 (2): "එකම වස්තුවක් හෝ ශ්‍රිතයක් ගැන සඳහන් කරන සියලුම ප්‍රකාශයන්ට අනුකූල වර්ගයක් තිබිය යුතුය; එසේ නොමැති නම් හැසිරීම නිර්වචනය කර නැත."
— ස්ටීව් ජෙසොප්
4
Rian බ්‍රයන්: "බාහිර int i;" මම කොහේ හෝ තැනක සිටින බව පවසයි, ඒ ගැන කරදර නොවන්න. "int i;" එයින් අදහස් වන්නේ මම පූර්ණ සංඛ්‍යාවක් වන අතර එහි ලිපිනය සහ විෂය පථය මෙහි තීරණය වේ.
— ඩේවිඩ් තෝර්න්ලි
12
Rian බ්‍රයන්: ඔබ වැරදියි. extern int iඑය නිකුතුවක් / නියම කිරීමක් බැවින් එය ප්‍රකාශයකි i. extern int iඑක් එක් සම්පාදන ඒකකයේ ඔබට අවශ්‍ය තරම් ප්‍රමාණයක් තිබිය හැකිය . int iකෙසේ වෙතත්, අර්ථ දැක්වීමකි. එය මෙම පරිවර්තන ඒකකයේ පූර්ණ සංඛ්‍යා සඳහා ඇති අවකාශය නිරූපණය කරන අතර iමෙම ආයතනයට එරෙහිව සියලු යොමු සම්බන්ධ කිරීමට සම්බන්ධකයට උපදෙස් දෙයි . ඔබට මෙම අර්ථ දැක්වීම් වලින් එකකට වඩා වැඩි හෝ අඩු නම්, සම්බන්ධකය පැමිණිලි කරනු ඇත.
— sbi
4
int i;ගොනුව / ගෝලීය විෂය පථය හෝ ශ්‍රිත විෂය පථය තුළ බ්‍රයන් යනු සී සහ සී ++ යන දෙකෙහිම අර්ථ දැක්වීමකි. C හි එය ගබඩාව වෙන් කරන නිසාත්, C ++ තුළ එයට බාහිර පිරිවිතරයක් හෝ සම්බන්ධතා-පිරිවිතරයක් නොමැති නිසාත් ය. මෙම ප්‍රමාණය එකම දෙයකට සමාන වන අතර එය sbi පවසයි: අවස්ථා දෙකේදීම මෙම ප්‍රකාශය මඟින් එම විෂය පථයේ “i” පිළිබඳ සියලු යොමු කිරීම් සම්බන්ධ කළ යුතු වස්තුව නියම කරයි.
— ස්ටීව් ජෙසොප්
4
nowunknown, පංති විෂය පථය තුළ ඔබට සාමාජිකයින් නැවත ප්‍රකාශ කළ නොහැකි බව පරෙස්සම් වන්න : struct A { double f(int, double); double f(int, double); };අවලංගු, ඇත්ත වශයෙන්ම. එය වෙනත් තැනකට අවසර ඇත. ඔබට දේවල් ප්‍රකාශ කළ හැකි සමහර ස්ථාන තිබේ, නමුත් නිර්වචනය නොකෙරේ: void f() { void g(); }වලංගු, නමුත් පහත සඳහන් නොවේ : void f() { void g() { } };. නිර්වචනයක් යනු කුමක්ද සහ ප්‍රකාශනයකට සැකිලි සම්බන්ධයෙන් සියුම් නීති තිබේ නම් - පරෙස්සම් වන්න! හොඳ පිළිතුරක් සඳහා +1.
— ජොහැන්නස් ෂෝබ් - litb
172

C ++ සම්මත අංශයෙන් 3.1:

ඒ ප්රකාශය පරිවර්තනය ඒකකය බවට හඳුන්වා නම් හෝ කලින් ප්රකාශ විසින් හඳුන්වා redeclares නම්. ප්‍රකාශයක් මඟින් මෙම නම්වල අර්ථ නිරූපණය සහ ගුණාංග නියම කරයි.

ඊළඟ ඡේදයේ (අවධාරණය මගේ) ප්‍රකාශයක් අර්ථ දැක්වීමක් මිස ...

... එය ශ්‍රිතයේ ශරීරය නියම නොකර ශ්‍රිතයක් ප්‍රකාශ කරයි:

void sqrt(double);  // declares sqrt

... එය පන්ති අර්ථ දැක්වීමක් තුළ ස්ථිතික සාමාජිකයෙකු ප්‍රකාශ කරයි:

struct X
{
    int a;         // defines a
    static int b;  // declares b
};

... එය පන්ති නාමයක් ප්‍රකාශ කරයි:

class Y;

... externආරම්භක හෝ ක්‍රියාකාරී ශරීරයක් නොමැතිව එහි මූල පදය අඩංගු වේ :

extern const int i = 0;  // defines i
extern int j;  // declares j
extern "C"
{
    void foo();  // declares foo
}

... හෝ වේ typedefහෝ usingප්රකාශයක්.

typedef long LONG_32;  // declares LONG_32
using namespace std;   // declares std

ප්‍රකාශයක් සහ අර්ථ දැක්වීමක් අතර වෙනස තේරුම් ගැනීම වැදගත් වීමට දැන් විශාල හේතුව: එක් අර්ථ දැක්වීමේ රීතිය . C ++ ප්‍රමිතියේ 3.2.1 වගන්තියෙන්:

කිසිදු පරිවර්තන ඒකකයක විචල්‍ය, ශ්‍රිත, පන්ති වර්ගය, ගණන් ගැනීමේ වර්ගය හෝ අච්චුවකට එකකට වඩා අර්ථ දැක්වීම් අඩංගු නොවිය යුතුය.

— මයිකල් ක්‍රිස්ටොෆික්
source
"පන්ති අර්ථ දැක්වීමක් තුළ ස්ථිතික සාමාජිකයෙකු ප්‍රකාශ කරයි" - ස්ථිතික සාමාජිකයා ආරම්භ කළත් මෙය සත්‍යයක් ද? අපට ආදර්ශය ගත struct x {static int b = 3; };හැකිද?
— ආර්.ජේ.ෆල්කොනර්
JRJFalconer ඔබ නිවැරදියි; ආරම්භය වන්නේ නැහැ අවශ්යයෙන්ම නිර්වචනය බවට ප්රකාශ හැරී (එක් බලාපොරොත්තු විය හැකි දේ පටහැනි, නිසැකව මම මේ පුදුම සොයා). නම් ආදර්ශය ඔබේ වෙනස් ඇත්තටම නීති විරෝධී bද ප්රකාශ කරයි const. Stackoverflow.com/a/3536513/1858225 සහ daniweb.com/software-development/cpp/threads/140739/… බලන්න .
— කයිල් ස්ට්‍රෑන්ඩ්
1
මෙය මට සිත්ගන්නා සුළුය. ඔබේ පිළිතුරට අනුව, C ++ හි ප්‍රකාශයක් ද අර්ථ දැක්වීමක් බව පෙනේ (ව්‍යතිරේක සහිතව), නමුත් C ප්‍රමිතියේ එය අනෙක් දෘෂ්ටිකෝණයෙන් (C99, 6.7, ප්‍රකාශ) උපුටා දක්වනු ලැබේ : “ හඳුනාගැනීමේ අර්ථ දැක්වීමකි එම අනන්‍යතාවය සඳහා වූ ප්‍රකාශයක්: [ඉන්පසු විවිධ අවස්ථා සඳහා නිර්ණායක]. එය බැලීමට විවිධ ක්‍රම, මම සිතමි. :)
— වික්ටර් සැමානියන්
ප්‍රකාශය යනු සම්පාදකයාට නමක් පිළිගැනීමයි (සම්පාදකයාට නම නීත්‍යානුකූල බව පැවසීමට, නම හඳුන්වා දෙනු ලබන්නේ යතුරු ලියනයකින් නොව අභිප්‍රායෙනි). අර්ථ දැක්වීම යනු නමක් සහ එහි අන්තර්ගතය සම්බන්ධ වූ ස්ථානයකි. නමෙහි අන්තර්ගතයට නාම යොමු කිරීමක් සම්බන්ධ කිරීම සඳහා සම්බන්ධකය විසින් අර්ථ දැක්වීම භාවිතා කරයි.
— ගබ් 是 好人
138

ප්‍රකාශය: "කොහේ හරි, මෝඩයෙක් සිටී."

අර්ථ දැක්වීම: "... මෙන්න මෙන්න!"

— කුළුණ
source
3
ප්‍රකාශය යනු සම්පාදකයාට නමක් පිළිගැනීමයි (සම්පාදකයාට නම නීත්‍යානුකූල බව පැවසීමට, නම හඳුන්වා දෙනු ලබන්නේ යතුරු ලියනයකින් නොව අභිප්‍රායෙනි). අර්ථ දැක්වීම යනු නමක් සහ එහි අන්තර්ගතය සම්බන්ධ වූ ස්ථානයකි. නමෙහි අන්තර්ගතයට නාම යොමු කිරීමක් සම්බන්ධ කිරීම සඳහා සම්බන්ධකය විසින් අර්ථ දැක්වීම භාවිතා කරයි.
— ගබ් 是 好人
47

C ++ හි සිත්ගන්නා සුළු අවස්ථා තිබේ (සමහර ඒවා C හි ද ඇත). සලකා බලන්න

T t;

එය කුමන වර්ගයක්ද යන්න මත පදනම්ව අර්ථ දැක්වීමක් හෝ ප්‍රකාශයක් විය හැකිය T:

typedef void T();
T t; // declaration of function "t"

struct X { 
  T t; // declaration of function "t".
};

typedef int T;
T t; // definition of object "t".

C ++ හි, සැකිලි භාවිතා කරන විට, තවත් දාරයක් තිබේ. 

template <typename T>
struct X { 
  static int member; // declaration
};

template<typename T>
int X<T>::member; // definition

template<>
int X<bool>::member; // declaration!

අවසාන ප්‍රකාශය අර්ථ දැක්වීමක් නොවීය . එය ස්ථිතික සාමාජිකයාගේ පැහැදිලි විශේෂීකරණය ප්‍රකාශ කිරීමකි X<bool>. එය සම්පාදකයාට මෙසේ කියයි: "එය ක්ෂණිකව ක්‍රියාත්මක X<bool>::memberකිරීමට නම්, ප්‍රාථමික අච්චුවෙන් සාමාජිකයාගේ අර්ථ දැක්වීම ක්ෂණිකව නොකරන්න, නමුත් වෙනත් තැනක ඇති අර්ථ දැක්වීම භාවිතා කරන්න". එය අර්ථ දැක්වීමක් කිරීමට, ඔබට ආරම්භකයක් සැපයිය යුතුය

template<>
int X<bool>::member = 1; // definition, belongs into a .cpp file.
— ජොහැන්නස් ෂෝබ් - ලිට්බ්
source
35

ප්රකාශය

වැඩසටහන් මූලද්‍රව්‍යයක් හෝ නමක් පවතින බව ප්‍රකාශන සම්පාදකයාට පවසයි. ප්‍රකාශයක් මඟින් වැඩසටහනකට නම් එකක් හෝ කිහිපයක් හඳුන්වා දෙයි. වැඩසටහනක එක් වරකට වඩා ප්‍රකාශ සිදුවිය හැකිය. එබැවින්, එක් එක් සම්පාදන ඒකකය සඳහා පන්ති, ව්‍යුහයන්, ගණන් කරන ලද වර්ග සහ වෙනත් පරිශීලක අර්ථ දක්වන ලද වර්ග ප්‍රකාශ කළ හැකිය.

අර්ථ දැක්වීම

නම විස්තර කරන කේතය හෝ දත්ත නිර්වචන මගින් නියම කෙරේ. නමක් භාවිතා කිරීමට පෙර එය ප්‍රකාශ කළ යුතුය.

— adatapost
source
ම්, ඔබට එක් එක් සම්පාදන ඒකකයේ පන්ති සහ එනූම් පවා අර්ථ දැක්විය හැකිද? අවම වශයෙන් මම පන්ති අර්ථ දැක්වීම් මගේ ශීර්ෂයන් තුළට දමා ඒවා සියල්ලම ඇතුළත් කරමි. ඒර්, class foo {}; වේ පන්ති අර්ථ දැක්වීම , නේද?
— sbi
1
ඔව්. කෙසේ වෙතත්, "පන්ති foo;" ප්‍රකාශයකි. එය සම්පාදකයාට පවසන්නේ foo යනු පන්තියක් බවයි. "පන්ති foo {};" යනු අර්ථ දැක්වීමකි. එය සම්පාදකයාට හරියටම පන්තියේ foo යනු කුමක්දැයි කියයි.
— ඩේවිඩ් තෝර්න්ලි
1
ව්යතිරේකය යනු පංති සාමාජික නාමයන් වන අතර ඒවා ප්රකාශයට පත් කිරීමට පෙර භාවිතා කළ හැකිය.
— ජොහැන්නස් ෂෝබ් - litb
1
ඔව්, ඒකයි මම අදහස් කළේ. එබැවින් ඔබට පහත සඳහන් දෑ කළ හැකිය: struct foo {void b () {f (); oid අවලංගු f (); }, f තවමත් ප්‍රකාශ කර නොමැති වුවද දෘශ්‍යමාන වේ. පහත සඳහන් දෑ ද ක්‍රියාත්මක වේ: struct foo {void b (int = bar ()); typedef int bar; };. එය ප්‍රකාශයට පත් කිරීමට පෙර “සියලු ක්‍රියාකාරී ආයතන, පෙරනිමි තර්ක, ඉදිකිරීම්කරු ctor-initializers” තුළ දැකිය හැකිය. ආපසු එන වර්ගයේ නොවේ :(
— ජොහැන්නස් ෂෝබ් - litb
1
it ලිට්බ්: එය ප්‍රකාශයට පත් කිරීමට පෙර නොපෙනේ, එය ප්‍රකාශනය පිටුපස අනන්‍යතාවය භාවිතා කිරීම පමණි . ඔව්, මම දන්නවා, බලපෑම බොහෝ අවස්ථාවන්ට සමාන වේ. නමුත් සෑම අවස්ථාවකම නොවේ, ඒ නිසා මම හිතන්නේ අපි නිවැරදි පැහැදිලි කිරීම භාවිතා කළ යුතුයි. - අපොයි, ඉන්න. පෙරනිමි තර්ක වලින් එය දැකිය හැකිද? හොඳයි, එය නිසැකවම මගේ අවබෝධය විනාශ කරයි. දමිත්! <pouts>
— sbi
22

C99 ප්‍රමිතියෙන් 6.7 (5):

ප්‍රකාශයක් මඟින් හඳුනාගැනීම් සමූහයක අර්ථ නිරූපණය සහ ගුණාංග නියම කරයි. ඒ අර්ථ දැක්වීම : හඳුන්වනයක් බව බව හඳුනාගැනීමේ සඳහා ප්රකාශ වේ

  • වස්තුවක් සඳහා, එම වස්තුව සඳහා ගබඩා වෙන් කිරීමට හේතු වේ;
  • ශ්‍රිතයක් සඳහා, ශ්‍රිත ශරීරය ඇතුළත් වේ;
  • ගණනය කිරීමේ නියතයක් හෝ යතුරු ලියනයක නමක් සඳහා, හඳුනාගැනීමේ ප්‍රකාශය (එකම) වේ.

C ++ ප්‍රමිතියෙන්, 3.1 (2):

ප්‍රකාශයක් යනු අර්ථ දැක්වීමකි එය ශ්‍රිතයේ ශරීරය නියම නොකර ශ්‍රිතයක් ප්‍රකාශ කරන්නේ නම් මිස, එහි බාහිර පිරිවිතර හෝ සම්බන්ධක-පිරිවිතර අඩංගු වන අතර ආරම්භක හෝ ක්‍රියාකාරී-ශරීරයක් නොවේ, එය පන්ති ප්‍රකාශනයක ස්ථිතික දත්ත සාමාජිකයෙකු ප්‍රකාශයට පත් කරයි, එය a පංති නාම ප්‍රකාශනය, නැතහොත් එය යතුරු ලියනයක ප්‍රකාශයක්, භාවිතා කිරීමේ ප්‍රකාශයක් හෝ භාවිතා කිරීමේ නියෝගයකි.

එවිට උදාහරණ කිහිපයක් තිබේ.

එතරම් සිත්ගන්නා සුළුය (නැතහොත් නැත, නමුත් මම ඒ ගැන තරමක් පුදුම වෙමි), typedef int myint;C99 හි අර්ථ දැක්වීමකි, නමුත් C ++ හි ප්‍රකාශයක් පමණි.

— ස්ටීව් ජෙසොප්
source
@onebyone: සම්බන්ධයෙන් typedef, එයින් අදහස් කරන්නේ එය C ++ වලින් නැවත නැවත කළ හැකි බව නොවේ, නමුත් C99 හි නොවේද?
— sbi
එය මා මවිතයට පත් කළ අතර, එක් පරිවර්තන ඒකකයක් සම්බන්ධයෙන් ගත් කල, ඔව් එම වෙනස තිබේ. නමුත් පැහැදිලිවම යතුරු ලියනය C99 හි විවිධ පරිවර්තන ඒකකවල පුනරාවර්තනය කළ හැකිය. C ට C ++ වැනි පැහැදිලි “එක් අර්ථ දැක්වීමේ රීතියක්” නොමැත, එබැවින් එහි ඇති නීති එයට ඉඩ දෙයි. C ++ එය ප්‍රකාශනයකට වෙනස් කිරීමට තෝරා ගත් අතර, එක් අර්ථ දැක්වීමේ රීතියක් මඟින් එය කුමන ආකාරයේ දේවලට අදාළ වේද යන්න ලැයිස්තුගත කරයි, සහ යතුරු ලියනය ඒවායින් එකක් නොවේ. යතුරු ලියනය අර්ථ දැක්වීමක් වුවද, ODR යටතේ C ++ හි පුනරාවර්තනයන්ට ඉඩ දෙනු ලැබේ. අනවශ්‍ය ලෙස අච්චාරු දමන බවක් පෙනේ.
— ස්ටීව් ජෙසොප්
... නමුත් මම අනුමාන කරන්නේ ODR හි ඇති ලැයිස්තුව ඇත්ත වශයෙන්ම අර්ථ දැක්විය හැකි සියලු දේ ලැයිස්තුගත කරයි. එසේ නම්, ලැයිස්තුව ඇත්ත වශයෙන්ම අතිරික්ත වන අතර එය ප්‍රයෝජනවත් විය යුතුය.
— ස්ටීව් ජෙසොප්
2
bsbi: ODR පවසයි "(1) කිසිදු පරිවර්තන ඒකකයක කිසිදු ... පන්ති වර්ගයක අර්ථ දැක්වීම් එකකට වඩා අඩංගු නොවිය යුතුය" සහ "(5) පන්ති වර්ගයක අර්ථ දැක්වීම් එකකට වඩා තිබිය හැකිය ... සෑම අර්ථ දැක්වීමක්ම වෙනත් පරිවර්තන ඒකකයක දිස්වේ ”ඉන්පසු“ අර්ථ දැක්වීම් සමාන වේ ”යන අමතර අවශ්‍යතා කිහිපයක්.
— ස්ටීව් ජෙසොප්
1
TeSteveJessop: ඔබ දන්නා පරිදි C11 නැවත නැවත යතුරු ලියනය කිරීමට ඉඩ දෙන බැවින් C11 ප්‍රමිතියට අනුව ඔබේ පිළිතුර යාවත්කාලීන කරන්න.
— විනාශ
17

Wiki.answers.com වෙතින්:

ප්‍රකාශනය යන වචනයේ තේරුම (සී වලින්) ඔබ සම්පාදකයාට වර්ගය, ප්‍රමාණය සහ ක්‍රියාකාරී ප්‍රකාශනය, ඕනෑම විචල්‍යයක පරාමිතීන්ගේ වර්ගය සහ ප්‍රමාණය හෝ ඔබේ වැඩසටහනේ පරිශීලක අර්ථ දක්වන ලද වර්ගය හෝ ක්‍රියාකාරිත්වය පිළිබඳව පවසන බවයි. ප්‍රකාශනයකදී කිසිදු විචල්‍යයක් සඳහා මතකයේ ඉඩක් වෙන් කර නොමැත . කෙසේ වෙතත්, මෙම වර්ගයේ විචල්‍යයක් නිර්මාණය වුවහොත් වෙන් කිරීමට කොපමණ ඉඩ ප්‍රමාණයක් සම්පාදකයා දනී.

උදාහරණයක් ලෙස, සියලු ප්‍රකාශ පහත දැක්වේ: 

extern int a; 
struct _tagExample { int a; int b; }; 
int myFunc (int a, int b);

අනෙක් අතට අර්ථ දැක්වීම යන්නෙන් අදහස් කරන්නේ ප්‍රකාශය කරන සියලු දේට අමතරව අවකාශය මතකයේ ද වෙන් කර ඇති බවයි. ඔබට "DEFINITION = DECLARATION + SPACE RESERVATION" යන්න අර්ථ දැක්වීමේ උදාහරණ වේ.

int a; 
int b = 0; 
int myFunc (int a, int b) { return a + b; } 
struct _tagExample example;

පිළිතුරු බලන්න .

— මාකින් ගිල්
source
3
මෙය ද, (වඩාත් අයට වඩා වුවත්) වැරදි: struct foo {};යනු අර්ථ දැක්වීම , ප්රකාශ නොවේ. ප්‍රකාශයක් fooවනු ඇත struct foo;. එයින්, සම්පාදකයා fooවස්තූන් සඳහා කොපමණ ඉඩක් වෙන් කළ යුතු දැයි නොදනී .
— sbi
1
Arc මාකින්: sbi පවසන්නේ "මෙම වර්ගයේ විචල්‍යයක් නිර්මාණය වුවහොත් වෙන් කරවා ගැනීමට කොපමණ ඉඩක් සම්පාදකයා දනී" යන්න සැමවිටම සත්‍ය නොවන බවයි. struct foo;ප්‍රකාශයකි, නමුත් එය සම්පාදකයාට foo හි ප්‍රමාණය නොකියයි. මම struct _tagExample { int a; int b; };එය අර්ථ දැක්වීමකි. එබැවින් මෙම සන්දර්භය තුළ එය ප්‍රකාශයක් ලෙස හැඳින්වීම නොමඟ යවන සුළුය. ඇත්ත වශයෙන්ම එය එකකි, මන්ද සියලු නිර්වචන ප්‍රකාශන වන නමුත් ඔබ එය යෝජනා කරන්නේ එය අර්ථ දැක්වීමක් නොවන බවයි. එය _tagExample හි අර්ථ දැක්වීමකි.
— ස්ටීව් ජෙසොප්
1
Ar මාසින් ගිල්: එයින් අදහස් කරන්නේ "පිළිතුරු" විකිය සැමවිටම නිවැරදි නොවන බවයි. මෙහි වැරදි තොරතුරු සඳහා මට අවතක්සේරු කළ යුතුය.
— ඩේවිඩ් තෝර්න්ලි
1
ඇඩැටපොස්ට් උපුටා දක්වා ඇති දේ සත්‍ය බව අපි ඉගෙන ගත්තද (IMO) ඇත්ත වශයෙන්ම ප්‍රශ්නයට පිළිතුරු සපයන්නේ නැත. මාකින් උපුටා ගත් දේ අසත්‍යය. ප්‍රමිති උපුටා දැක්වීම සත්‍යයක් වන අතර ප්‍රශ්නයට පිළිතුරු සපයයි, නමුත් හිස හෝ වලිගය සෑදීම ඉතා අපහසුය.
— ස්ටීව් ජෙසොප්
1
Av ඩේවිඩ් තෝර්න්ලි - ගැටළුවක් නොවේ :) මෙම වෙබ් අඩවිය ගැන මෙයයි. අපි තොරතුරු තෝරාගෙන සත්‍යාපනය කරමු .
— මාකින් ගිල්
13

සී ++ 11 යාවත්කාලීන කිරීම

C ++ 11 ට අදාළ පිළිතුරක් මා නොදකින බැවින් මෙහි එකකි.

ප්‍රකාශයක් යනු / n ප්‍රකාශ නොකරන්නේ නම් එය අර්ථ දැක්වීමකි :

  • පාරාන්ධ enum - enum X : int;
  • සැකිල්ල පරාමිතිය - ටී දීtemplate<typename T> class MyArray;
  • පරාමිති ප්‍රකාශනය - x සහ y inint add(int x, int y);
  • අන්වර්ථ ප්‍රකාශනය - using IntVector = std::vector<int>;
  • ස්ථිතික ප්‍රකාශ ප්‍රකාශය - static_assert(sizeof(int) == 4, "Yikes!")
  • ආරෝපණ ප්‍රකාශනය (ක්‍රියාත්මක කිරීම-අර්ථ දක්වා ඇත)
  • හිස් ප්‍රකාශය ;

ඉහත ලැයිස්තුවෙන් C ++ 03 වෙතින් උරුම වූ අමතර වගන්ති:

  • කාර්යය පකාශය - එකතු දීint add(int x, int y);
  • ප්‍රකාශය හෝ සම්බන්ධක පිරිවිතර අඩංගු බාහිර පිරිවිතර - extern int a;හෝextern "C" { ... };
  • පන්තියක ස්ථිතික දත්ත සාමාජිකයා - x inclass C { static int x; };
  • පන්ති / ව්‍යුහ ප්‍රකාශනය - struct Point;
  • typedef ප්‍රකාශනය - typedef int Int;
  • ප්‍රකාශය භාවිතා කරමින් - using std::cout;
  • විධානය භාවිතා කරමින් - using namespace NS;

අච්චු ප්‍රකාශනය යනු ප්‍රකාශයකි. අච්චු ප්‍රකාශනය යනු එහි ප්‍රකාශනය මඟින් ශ්‍රිතයක්, පන්තියක් හෝ ස්ථිතික දත්ත සාමාජිකයෙකු අර්ථ දක්වන්නේ නම් අර්ථ දැක්වීමකි.

ප්‍රකාශය සහ අර්ථ දැක්වීම අතර වෙනස හඳුනා ගන්නා ප්‍රමිතියෙන් උදාහරණ අතර ඒවා අතර ඇති සූක්ෂ්ම දේ තේරුම් ගැනීමට මට උපකාරී විය.

// except one all these are definitions
int a;                                  // defines a
extern const int c = 1;                 // defines c
int f(int x) { return x + a; }          // defines f and defines x
struct S { int a; int b; };             // defines S, S::a, and S::b
struct X {                              // defines X
    int x;                              // defines non-static data member x
    static int y;                       // DECLARES static data member y
    X(): x(0) { }                       // defines a constructor of X
};
int X::y = 1;                           // defines X::y
enum { up , down };                     // defines up and down
namespace N { int d; }                  // defines N and N::d
namespace N1 = N;                       // defines N1
X anX;                                  // defines anX


// all these are declarations
extern int a;                           // declares a
extern const int c;                     // declares c
int f(int);                             // declares f
struct S;                               // declares S
typedef int Int;                        // declares Int
extern X anotherX;                      // declares anotherX
using N::d;                             // declares N::d


// specific to C++11 - these are not from the standard
enum X : int;                           // declares X with int as the underlying type
using IntVector = std::vector<int>;     // declares IntVector as an alias to std::vector<int>
static_assert(X::y == 1, "Oops!");      // declares a static_assert which can render the program ill-formed or have no effect like an empty declaration, depending on the result of expr
template <class T> class C;             // declares template class C
;                                       // declares nothing
— legends2k
source
6

අර්ථ දැක්වීම: 

extern int a;      // Declaration 
int a;             // Definition
a = 10             // Initialization
int b = 10;        // Definition & Initialization

අර්ථ දැක්වීම විචල්‍යය වර්ගයක් සමඟ සම්බන්ධ කර මතකය වෙන් කරයි, නමුත් ප්‍රකාශනය මඟින් වර්ගය නියම කරන නමුත් මතකය වෙන් නොකරයි. අර්ථ දැක්වීමට පෙර විචල්‍යය යොමු කිරීමට අවශ්‍ය විට ප්‍රකාශනය වඩාත් ප්‍රයෝජනවත් වේ.

ආරම්භය සමඟ අර්ථ දැක්වීම පටලවා නොගන්න. දෙකම වෙනස් වේ, ආරම්භ කිරීම විචල්‍යයට වටිනාකමක් ලබා දෙයි. ඉහත උදාහරණය බලන්න.

අර්ථ දැක්වීමේ උදාහරණ කිහිපයක් පහත දැක්වේ.

int a;
float b;
double c;

දැන් ක්‍රියාකාරී ප්‍රකාශනය:

int fun(int a,int b);

ශ්‍රිතය අවසානයේ අර්ධ සළකුණ සටහන් කරන්න, එවිට එය ප්‍රකාශයක් පමණක් යැයි කියනු ලැබේ. Compiler වැඩසටහන බව කොහේ හරි ක්රියාව කරන බව දන්නා අර්ථ බව පරමාදර්ශයක් සමඟ. දැන් සම්පාදකයාට ශ්‍රිතයක් ලැබුනේ නම් මේ වගේ දෙයක් අමතන්න

int b=fun(x,y,z);

එවැනි කාර්යයක් නොමැති බව පවසමින් සම්පාදකයා දෝෂයක් විසි කරයි. එයට එම ශ්‍රිතය සඳහා කිසිදු මූලාකෘතියක් නොමැති බැවිනි.

වැඩසටහන් දෙකක් අතර වෙනස සැලකිල්ලට ගන්න.

වැඩසටහන 1

#include <stdio.h>
void print(int a)
{
     printf("%d",a);
}
main()
{
    print(5);
}

මෙහි දී මුද්‍රණ ශ්‍රිතය ප්‍රකාශයට පත් කර අර්ථ දක්වා ඇත. අර්ථ දැක්වීමෙන් පසුව ශ්‍රිත ඇමතුම එන බැවින්. දැන් ඊළඟ වැඩසටහන බලන්න.

වැඩසටහන 2

 #include <stdio.h>
 void print(int a); // In this case this is essential
 main()
 {
    print(5);
 }
 void print(int a)
 {
     printf("%d",a);
 }

එය අත්‍යවශ්‍ය වන්නේ ශ්‍රිත ඇමතුම අර්ථ දැක්වීමට පෙර බැවින් සම්පාදකයා එවැනි ශ්‍රිතයක් තිබේදැයි දැන සිටිය යුතුය. එබැවින් අපි සම්පාදකයාට දැනුම් දෙන ශ්‍රිතය ප්‍රකාශ කරමු.

අර්ථ දැක්වීම:

ශ්‍රිතයක් අර්ථ දැක්වීමේ මෙම කොටස අර්ථ දැක්වීම ලෙස හැඳින්වේ. එය ශ්‍රිතය තුළ කළ යුතු දේ පවසයි.

void print(int a)
{
    printf("%d",a);
}
— ශ්‍රීධරන්
source
2
int a; //declaration; a=10; //definitionමෙය සම්පූර්ණයෙන්ම වැරදිය. ස්වයංක්‍රීය ගබඩා කාල වස්තූන් ගැන කතා කරන විට (බාහිර වැනි වෙනත් ගබඩා පංති පිරිවිතරයක් සමඟ ප්‍රකාශයට පත් නොකරන ලද ශ්‍රිත අර්ථ දැක්වීමක් තුළ ප්‍රකාශයට පත් කරන ලද වස්තූන්) මේවා සැමවිටම අර්ථ දැක්වීම් වේ.
— ජෝයි පබාලිනාස්
ග්‍රහණය කර ගත යුතු ප්‍රධාන වෙනස නම් ප්‍රකාශයක් “මෙම ගති ලක්ෂණ ඇති යම් ආකාරයක යමක් තිබේ (යනාදිය)” යැයි පැවසීම වන අතර අර්ථ දැක්වීමක් “මම මෙම ගති ලක්ෂණ සමඟ යමක් ප්‍රකාශ කරමි, එසේම මම එය මෙහි ක්ෂණිකව ස්ථාපනය කරමි හොඳින්." ඔබට ස්වයංක්‍රීය ගබඩා කාල වස්තු ප්‍රකාශ කිරීමට ඉදිරියට යා නොහැකි බැවින් ඒවා සැමවිටම අර්ථ දැක්වීම් වනු ඇත.
— ජෝයි පබාලිනාස්
මට සැමවිටම අමතක වී ඇති සමහර අමුතු ටයිප් කොන අවස්ථා හැරුණු විට, නියමය නම් සියලු අර්ථ දැක්වීම් ප්‍රකාශන වේ. ඒ ගැන සිතන්න; ඔබ යමක් ක්ෂණිකව ස්ථාපනය කරන විට, එම කාරණය පවතින බවත් එහි ගති ලක්ෂණ නිවැරදි බවත් ඔබ සම්පාදකයාට පැවසිය යුතුය.
— ජෝයි පබාලිනාස්
ඔබගේ පළමු අදහස් අනුව පිළිතුර යාවත්කාලීන කරන ලදි. කෙසේ වෙතත් මම මෙම ප්‍රකාශය සමඟ එකඟ නොවෙමි "ඔබ යමක් ක්ෂණිකව ස්ථාපනය කරන විට, එම කාරණය පවතින බව ඔබ සම්පාදකයාට පැවසිය යුතුය". ක්ෂණිකව ක්‍රියාත්මක කිරීමේදී අපි සෑම විටම lhs වර්ගය සඳහන් නොකරමු. උදා: a = 10. අපි මෙහි කිසිදු "ගති ලක්ෂණ" සඳහන් නොකරමු.
— ශ්‍රීධරන්
5

නාම පද තේරුම් ගැනීමට, අපි පළමුව ක්‍රියා පද කෙරෙහි අවධානය යොමු කරමු.

ප්රකාශ කරන්න - නිල වශයෙන් ප්රකාශ කිරීමට; ප්‍රකාශ කරන්න

අර්ථ දක්වන්න - පැහැදිලිව හා සම්පූර්ණයෙන් (යමෙකු හෝ යමක්) පෙන්වීමට හෝ විස්තර කිරීමට

ඉතින්, ඔබ යමක් ප්‍රකාශ කරන විට, ඔබ එය කුමක්දැයි කියන්න .

// declaration
int sum(int, int);

මෙම රේඛාව C ශ්‍රිතයක් ප්‍රකාශයට පත් කරන අතර එය sumවර්ගයේ තර්ක දෙකක් ගෙන intනැවත ලබා දෙයි int. කෙසේ වෙතත්, ඔබට තවමත් එය භාවිතා කළ නොහැක.

එය සැබවින්ම ක්‍රියාත්මක වන ආකාරය ඔබ සපයන විට , එය අර්ථ දැක්වීමකි.

// definition
int sum(int x, int y)
{
    return x + y;
}
— කරෝලි නයිස්ටෝර්
source
4

අර්ථ දැක්වීම යන්නෙන් අදහස් කරන්නේ සත්‍ය ශ්‍රිතය ලිවීම සහ ප්‍රකාශනය යනු උදා 

void  myfunction(); //this is simple declaration

සහ 

void myfunction()
{
 some statement;    
}

මෙය ශ්‍රිත ක්‍රියාකාරිත්වයේ අර්ථ දැක්වීමකි

— Flexo
source
1
වර්ග සහ වස්තු ගැන කුමක් කිව හැකිද?
— sbi
4

නියමය:

  • ඒ ප්රකාශය මතකයේ විචල්ය දත්ත පරිවර්තනය කරන්නේ කෙසේද යන්න සම්පාදකවරයා කියයි. සෑම ප්රවේශයක් සඳහාම මෙය අවශ්ය වේ.

  • ඒ නිර්වචනය විචල්ය පවතින කිරීමට මතක රඳවා තබා ගනී. පළමු ප්‍රවේශයට පෙර මෙය හරියටම වරක් සිදුවිය යුතුය.

— bjhend
source
2
මෙය දරන්නේ වස්තූන් සඳහා පමණි. වර්ග සහ කාර්යයන් ගැන කුමක් කිව හැකිද?
— කක්ෂයේ සැහැල්ලු රේස්
3

ප්‍රකාශනය සහ අර්ථ දැක්වීම අතර වෙනස තේරුම් ගැනීමට අප එකලස් කිරීමේ කේතය දැකිය යුතුය:

uint8_t   ui8 = 5;  |   movb    $0x5,-0x45(%rbp)
int         i = 5;  |   movl    $0x5,-0x3c(%rbp)
uint32_t ui32 = 5;  |   movl    $0x5,-0x38(%rbp)
uint64_t ui64 = 5;  |   movq    $0x5,-0x10(%rbp)
double   doub = 5;  |   movsd   0x328(%rip),%xmm0        # 0x400a20
                        movsd   %xmm0,-0x8(%rbp)

මෙය අර්ථ දැක්වීම පමණි:

ui8 = 5;   |   movb    $0x5,-0x45(%rbp)
i = 5;     |   movl    $0x5,-0x3c(%rbp)
ui32 = 5;  |   movl    $0x5,-0x38(%rbp)
ui64 = 5;  |   movq    $0x5,-0x10(%rbp)
doub = 5;  |   movsd   0x328(%rip),%xmm0        # 0x400a20
               movsd   %xmm0,-0x8(%rbp)

ඔබට පෙනෙන පරිදි කිසිවක් වෙනස් නොවේ.

ප්‍රකාශනය අර්ථ දැක්වීමට වඩා වෙනස් වන්නේ එය සම්පාදකයා විසින් පමණක් භාවිතා කරන තොරතුරු ලබා දෙන බැවිනි. උදාහරණයක් ලෙස uint8_t සම්පාදකයාට asm function movb භාවිතා කරන ලෙස පවසන්න.

එය බලන්න:

uint def;                  |  no instructions
printf("some stuff...");   |  [...] callq   0x400450 <printf@plt>
def=5;                     |  movb    $0x5,-0x45(%rbp)

ප්‍රකාශයට සමාන ප්‍රකාශයක් නොමැති බැවින් එය ක්‍රියාත්මක කළ යුතු දෙයක් නැත.

තව දුරටත් ප්‍රකාශනය විචල්‍යයේ විෂය පථය සම්පාදකයාට කියයි.

ප්‍රකාශය යනු විචල්‍යයේ නිවැරදි භාවිතය තහවුරු කිරීම සඳහා සම්පාදකයා විසින් භාවිතා කරන තොරතුරක් බවත් යම් මතකයක් යම් විචල්‍යයකට කොපමණ කාලයක් අයත්ද යන්නත් අපට පැවසිය හැකිය.

— princio
source
2

ප්‍රකාශයක් යනු ආචයනයක් වෙන් කර නොමැති හඳුනාගැනීමක් වන අතර අර්ථ දැක්වීමක් ඇත්ත වශයෙන්ම ප්‍රකාශිත අනන්‍යතාවයකින් ගබඩාව වෙන් කරයි.

එක් සිත්ගන්නාසුලු සිතුවිල්ලක් - පන්තියේ හෝ ශ්‍රිතයේ වර්ගය තොරතුරු සමඟ සම්බන්ධ වන තුරු අච්චුවකට ගබඩාව වෙන් කළ නොහැක. එසේ නම්, අච්චු හඳුනාගැනීම ප්‍රකාශයක් හෝ අර්ථ දැක්වීමක් ද? ගබඩාවක් වෙන් කර නොමැති බැවින් එය ප්‍රකාශයක් විය යුතු අතර, ඔබ හුදෙක් අච්චු පන්තිය හෝ ශ්‍රිතය 'මූලාකෘතිකරණය' කරයි.

1
ඔබේ අර්ථ දැක්වීම වැරදියි, නමුත් ක්‍රියාකාරී අර්ථ දැක්වීම් සම්බන්ධයෙන් "ගබඩා අර්ථ දැක්වීම" සැමවිටම අමුතුයි. සැකිලි සම්බන්ධයෙන්: මෙය template<class T> struct foo;අච්චු ප්‍රකාශයක් වන අතර මෙයද template<class T> void f();වේ. අච්චු අර්ථ දැක්වීම් පන්ති / ශ්‍රිත අර්ථ දැක්වීම් එකම ආකාරයකින් පිළිබිඹු කරයි. ( අච්චුවේ නම වර්ගයක් හෝ ක්‍රියාකාරී නාමයක් නොවන බව සලකන්න . ඔබට මෙය දැකිය හැකි එක් ස්ථානයක් වන්නේ ඔබට අච්චුවක් වෙනත් අච්චු වර්ග පරාමිතියක් ලෙස සම්මත කළ නොහැකි විටය. ඔබට වර්ග වෙනුවට අච්චු යැවීමට අවශ්‍ය නම්, ඔබට අච්චු ආකෘති පරාමිතීන් අවශ්‍ය වේ. )
— sbi
'ගබඩා අර්ථ දැක්වීම' අමුතු බව එකඟ විය, විශේෂයෙන් ක්‍රියාකාරී අර්ථ දැක්වීම් සම්බන්ධයෙන්. ප්‍රකාශය int foo () වන අතර අර්ථ දැක්වීම int foo () {// මෙහි සමහර කේත ..}. මට සාමාන්‍යයෙන් මගේ කුඩා මොළය හුරුපුරුදු සංකල්ප සමඟ ඔතා තැබිය යුතුය - 'ගබඩා කිරීම' යනු අවම වශයෙන් එය මා වෙත කෙලින්ම තබා ගත හැකි එක් ක්‍රමයකි ... :)
2

සමාන පිළිතුරු මෙතැනින් සොයා ගන්න: සී හි තාක්ෂණික සම්මුඛ පරීක්ෂණ ප්‍රශ්න .

ඒ ප්රකාශය වැඩසටහන නමක් ලබා; එය නිර්වචනය වැඩසටහන තුළ අස්තිත්වයක් (උදා: වර්ගය, උදාහරණයක් වශයෙන්, ක්රියාකාරිත්වය හා) අනන්ය විස්තරයක් සපයයි. ප්‍රකාශයන් යම් විෂය පථයකින් පුනරාවර්තනය කළ හැකිය, එය යම් විෂය පථයක් තුළ නමක් හඳුන්වා දෙයි.

ප්‍රකාශයක් යනු අර්ථ දැක්වීමක් මිස:

  • ප්‍රකාශය මඟින් එහි ශරීරය නියම නොකර ශ්‍රිතයක් ප්‍රකාශ කරයි,
  • ප්‍රකාශනයේ බාහිර පිරිවිතරයක් අඩංගු වන අතර ආරම්භක හෝ ක්‍රියාකාරී ශරීරයක් නොමැත,
  • ප්‍රකාශනය යනු පන්ති අර්ථ දැක්වීමකින් තොරව ස්ථිතික පන්ති දත්ත සාමාජිකයෙකු ප්‍රකාශ කිරීමකි,
  • ප්‍රකාශනය යනු පන්ති නාම අර්ථ දැක්වීමකි,

අර්ථ දැක්වීමක් යනු ප්‍රකාශයක් මිස:

  • අර්ථ දැක්වීම මඟින් ස්ථිතික පන්ති දත්ත සාමාජිකයෙකු අර්ථ දක්වයි,
  • නිර්වචනය මඟින් පේළිගත නොවන සාමාජික ශ්‍රිතයක් අර්ථ දක්වයි.
— සන්තෝෂ්
source
1

මෙය ඇත්තෙන්ම රසවත් යැයි හැඟෙනු ඇත, නමුත් නියමයන් මගේ හිසෙහි තබා ගැනීමට මට හැකි හොඳම ක්‍රමය එයයි:

ප්‍රකාශය: තෝමස් ජෙෆර්සන් කතාවක් කරමින් සිටින පින්තූරය ... "මෙම මූලාශ්‍ර කේතය තුළ මෙම ආහාරය පවතින බව මම ප්‍රකාශ කරමි !!!"

අර්ථ දැක්වීම: ශබ්ද කෝෂයක් පින්තාරු කරන්න, ඔබ සොයන්නේ ෆූ සහ එහි තේරුම කුමක්ද යන්නයි.

— එය පීට්
source
1

ප්‍රකාශයක් සම්පාදකයාට සංකේත නාමයක් ඉදිරිපත් කරයි. අර්ථ දැක්වීම යනු සංකේතය සඳහා ඉඩ වෙන් කරන ප්‍රකාශයකි.

int f(int x); // function declaration (I know f exists)

int f(int x) { return 2*x; } // declaration and definition
— hdante
source
1

GNU C පුස්තකාල අත්පොතට අනුව ( http://www.gnu.org/software/libc/manual/html_node/Header-Files.html )

C හි ප්‍රකාශයක් හුදෙක් ශ්‍රිතයක් හෝ විචල්‍යයක් පවතින බවට තොරතුරු සපයන අතර එහි වර්ගය ලබා දෙයි. ශ්‍රිත ප්‍රකාශයක් සඳහා, එහි තර්ක වර්ග පිළිබඳ තොරතුරු ද සැපයිය හැකිය. ප්‍රකාශවල පරමාර්ථය නම් ප්‍රකාශිත විචල්‍යයන් සහ ශ්‍රිතයන් වෙත යොමු කිරීම් නිවැරදිව සැකසීමට සම්පාදකයාට ඉඩ දීමයි. අර්ථ දැක්වීමක්, අනෙක් අතට, ඇත්ත වශයෙන්ම විචල්‍යයක් සඳහා ආචයනය වෙන් කරයි හෝ ශ්‍රිතයක් කරන්නේ කුමක්දැයි කියයි.

— ලිනක්ස්බේබ්
source
0

ඔබ බාහිර ගබඩා පංතිය භාවිතා කරන විට ප්‍රකාශනය සහ අර්ථ දැක්වීම යන සංකල්පය අන්තරායක් වනු ඇත, මන්ද ඔබේ අර්ථ දැක්වීම වෙනත් ස්ථානයක පවතින අතර ඔබ ඔබේ දේශීය කේත ගොනුවේ (පිටුව) විචල්‍යය ප්‍රකාශ කරයි. C සහ C ++ අතර ඇති එක් වෙනසක් නම්, C හි ප්‍රකාශයන් සාමාන්‍යයෙන් ශ්‍රිතයක හෝ කේත පිටුවක ආරම්භයේදීම සිදු කිරීමයි. C ++ හි එය එසේ නොවේ. ඔබට කැමති ස්ථානයක ප්‍රකාශ කළ හැකිය.

— achoora
source
1
මෙය ප්‍රකාශය අර්ථ දැක්වීම සමඟ ව්‍යාකූල කරන අතර එය සරල වැරදිය.
— sbi
0

මගේ ප්‍රියතම උදාහරණය "int Num = 5" මෙහි ඔබේ විචල්‍යය 1. int 2 ලෙස අර්ථ දක්වා ඇති අතර එය Num ලෙස ප්‍රකාශයට පත් කර ඇත. අප

  • ගොඩනඟන ලද හෝ පන්තියක් හෝ ව්‍යුහයක් විය හැකි වස්තුවක වර්ගය නිර්වචනය කරන්න.
  • වස්තුවක නම ප්‍රකාශ කරන්න, එබැවින් විචල්‍යතා, ක්‍රියාකාරකම් ආදිය ඇතුළත් නමක් ඇති ඕනෑම දෙයක් ප්‍රකාශයට පත් කර ඇත.

පංතියක් හෝ ව්‍යුහයක් මඟින් වස්තු පසුව භාවිතා කරන විට එය අර්ථ දක්වන්නේ කෙසේද යන්න වෙනස් කිරීමට ඔබට ඉඩ සලසයි. උදාහරණයක් වශයෙන්

  • යමෙකුට නිශ්චිතව අර්ථ දක්වා නැති විෂමජාතීය විචල්‍යයක් හෝ අරාවක් ප්‍රකාශ කළ හැකිය.
  • C ++ හි ඕෆ්සෙට් එකක් භාවිතා කිරීමෙන් ප්‍රකාශිත නමක් නොමැති වස්තුවක් ඔබට අර්ථ දැක්විය හැකිය.

අපි ක්‍රමලේඛනය ඉගෙන ගන්නා විට මෙම පද දෙක බොහෝ විට ව්‍යාකූල වන්නේ අප බොහෝ විට එකම වේලාවක කරන බැවිනි.

— ජේසන් කේ.
source
එස්බීගේ පිළිතුර මෙතරම් පිරිසක් උඩු යටිකුරු කළේ මන්දැයි මට තේරෙන්නේ නැත. මම පිළිතුරු බ්ජෙන්ඩ් විසින් ඉදිරිපත් කළෙමි, එය මට වඩා හොඳ, සංක්ෂිප්ත, නිවැරදි හා කාලෝචිත ය. අවුරුදු 4 කට පසු එසේ කළ පළමු පුද්ගලයා මම බව දුටු විට මට කණගාටු විය.
— ජේසන් කේ.
0

ක්‍රියාත්මක කළ හැකි පරම්පරාවක අදියර:

(1) පෙර සකසනය -> (2) පරිවර්තක / සම්පාදක -> (3) සම්බන්ධකය

දෙවන අදියරේදී (පරිවර්තක / සම්පාදක), අපගේ කේතයේ ප්‍රකාශන ප්‍රකාශයන් සම්පාදකයාට පවසන්නේ අනාගතයේදී අපි මේවා භාවිතා කිරීමට යන බවත් පසුව ඔබට අර්ථ දැක්වීම සොයාගත හැකි බවත්ය.

පරිවර්තකයා එය සහතික කර ගන්න: කුමක්ද? ප්‍රකාශය යන්නෙන් අදහස් වේ

සහ (3) අදියර (සම්බන්ධක) හට දේවල් බැඳීමට අර්ථ දැක්වීමක් අවශ්‍ය වේ

සම්බන්ධකය එය සහතික කර ගන්න: කොහෙද? අර්ථ දැක්වීම යන්නෙන් අදහස් වේ

— ජීත් පරික්
source
0

කේ ඇන්ඩ් ආර් (2 වන සංස්කරණය) පුරා ඉතා පැහැදිලි අර්ථ දැක්වීම් තිබේ; එය ඒවා එක තැනක තබා ඒවා එක ලෙස කියවීමට උපකාරී වේ:

“අර්ථ දැක්වීම” යන්නෙන් අදහස් කරන්නේ විචල්‍යය නිර්මාණය කරන ලද හෝ පවරා ඇති ගබඩාවයි; “ප්‍රකාශනය” යන්නෙන් විචල්‍යයේ ස්වභාවය ප්‍රකාශ කර ඇති නමුත් ගබඩාවක් වෙන් නොකෙරේ. [p. 33]

...

බාහිර විචල්‍යයක් ප්‍රකාශ කිරීම සහ එහි අර්ථ දැක්වීම අතර වෙනස හඳුනා ගැනීම වැදගත්ය . ප්‍රකාශයක් මඟින් විචල්‍යයක ගුණාංග ප්‍රකාශයට පත් කරයි (මූලික වශයෙන් එහි වර්ගය); අර්ථ දැක්වීමක් මඟින් ගබඩාව පසෙකට දමනු ලැබේ. රේඛා නම්

int sp;
double val[MAXVAL]

ඕනෑම ශ්‍රිතයකට පිටතින් දිස්වන අතර, ඒවා බාහිර විචල්‍යයන් නිර්වචනය කරන spඅතර val, ගබඩාව පසෙකට දමනු ඇති අතර, එම ප්‍රභව ගොනුවේ ඉතිරි ප්‍රකාශය ලෙසද ක්‍රියා කරයි.

අනෙක් අතට, රේඛා

extern int sp;
extern double val[];

ප්රකාශ කරන මූල ගොනුව ඉතිරි spයනු intඒ valකියන්නේ double(එහි විශාලත්වය වෙනත් තැන්වල තීරණය වේ) රැසක්, නමුත් ඔවුන් සඳහා වූ විචල්ය හෝ වෙන් ගබඩා නිර්මාණය කරන්නේ නැහැ.

ප්‍රභව වැඩසටහන සකස් කරන සියලුම ලිපිගොනු අතර බාහිර විචල්‍යයක එක් අර්ථ දැක්වීමක් පමණක් තිබිය යුතුය . ... අරාව ප්‍රමාණ නිර්වචනය සමඟ නියම කළ යුතු නමුත් externප්‍රකාශයක් සමඟ විකල්ප වේ . [පි. 80-81]

...

ප්‍රකාශන මගින් එක් එක් අනන්‍යතාවයට ලබා දී ඇති අර්ථ නිරූපණය නියම කරයි; ඒවා අනන්‍යතාවය හා සම්බන්ධිත සංචිත අවශ්‍ය නොවේ. ආචයන සංචිතය අර්ථ දැක්වීම් ලෙස හැඳින්වේ . [p. 210]

— බ්‍රැඩ් සොලමන්
source
-1

ප්‍රකාශනය යනු විචල්‍යයකට නම සහ වර්ගය ලබා දීම (විචල්‍ය ප්‍රකාශනයේ දී), උදා: 

int i;

හෝ ශරීරයෙන් තොර ශ්‍රිතයකට නම, ආපසු වර්ගය සහ පරාමිති (වර්ග) ලබා දෙන්න (ශ්‍රිත ප්‍රකාශනයේදී) 

int max(int, int);

අර්ථ දැක්වීම යන්නෙන් අදහස් කරන්නේ විචල්‍යයකට අගය පැවරීම (විචල්‍ය අර්ථ දැක්වීමේදී), උදා:

i = 20;

හෝ ශ්‍රිතයකට ශරීරය (ක්‍රියාකාරිත්වය) සැපයීම / එකතු කිරීම ශ්‍රිත අර්ථ දැක්වීම ලෙස හැඳින්වේ, උදා: 

int max(int a, int b)
{
   if(a>b)   return a;
   return b;  
}

බොහෝ කාල ප්‍රකාශනය සහ අර්ථ දැක්වීම එකට කළ හැක්කේ:

int i=20;

සහ:

int max(int a, int b)
{
    if(a>b)   return a;
    return b;    
}

ඉහත අවස්ථාවන්හිදී අපි අර්ථ දැක්වීමේ දී සහ ප්රකාශ විචල්ය iහා function max().

— පූනීත් පුරෝහිත්
source
සකාට අගය / ශරීරය සඳහා විචල්ය / ක්රියාවන් සඳහා අර්ථ දැක්වීම සැබෑ තේරුම නම් ප්රකාශ මාර්ගයෙන් විචල්ය / ක්රියාවන් සඳහා නම, වර්ගය ලබා ඇති ෙහයින්ද
— Puneet Purohit
ඔබට වටිනාකමක් ලබා නොදී යමක් අර්ථ දැක්විය හැකිය.
— කක්ෂයේ සැහැල්ලු ධාවන තරඟ
1
මේ ආකාරයටම:int x;
— කක්ෂයේ සැහැල්ලු ධාවන
විචල්ය එහි ප්රකාශ එහි defination නොවන x
— Puneet Purohit
2
නැත, එය දෙකම වේ. ඔබ ආරම්භය සමඟ අර්ථ දැක්වීම ව්‍යාකූල කරයි.
— කක්ෂයේ සැහැල්ලු ධාවන තරඟ
By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.