企业官网建设流程全解析

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

// reference_type_function_arguments.cpp

structDate

{

shortDayOfWeek;

shortMonth;

shortDay;

shortYear;

};

// Create a Julian date of the form DDDYYYY

// from a Gregorian date.

longJulianFromGregorian( Date& GDate )

{

staticintcDaysInMonth[] = {

31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31

};

longJDate = 0;

// Add in days for months already elapsed.

for(inti = 0; i < GDate.Month - 1; ++i )

JDate += cDaysInMonth[i];

// Add in days for this month.

JDate += GDate.Day;

// Check for leap year.

if( GDate.Year % 100 != 0 && GDate.Year % 4 == 0 )

JDate++;

// Add in year.

JDate *= 10000;

JDate += GDate.Year;

returnJDate;

}

intmain()

{

}

1

longJulianFromGregorian(constDate& GDate );

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

// refType_function_returns.cpp

// compile with: /EHsc

#include <iostream>

usingnamespacestd;

classPoint

{

public:

// Define "accessor" functions as

// reference types.

unsigned& x();

unsigned& y();

private:

// Note that these are declared at class scope:

unsigned obj_x;

unsigned obj_y;

};

unsigned& Point :: x()

{

returnobj_x;

}

unsigned& Point :: y()

{

returnobj_y;

}

intmain()

{

Point ThePoint;

// Use x() and y() as l-values.

ThePoint.x() = 7;

ThePoint.y() = 9;

// Use x() and y() as r-values.

cout <<"x = "<< ThePoint.x() <<"\n"

<<"y = "<< ThePoint.y() <<"\n";

}

1

2

x = 7

y = 9

1

2

3

4

5

6

7

// C4172 means Don't do this!!!

Foo& GetFoo()

{

Foo f;

...

returnf;

}// f is destroyed here

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

72

73

74

75

76

77

78

79

80

81

82

83

84

85

86

87

88

89

90

91

92

93

94

95

96

97

98

99

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

// references_to_pointers.cpp

// compile with: /EHsc

#include <iostream>

#include <string>

// STL namespace

usingnamespacestd;

enum{

sizeOfBuffer = 132

};

// Define a binary tree structure.

structBTree {

char*szText;

BTree *Left;

BTree *Right;

};

// Define a pointer to the root of the tree.

BTree *btRoot = 0;

intAdd1( BTree **Root,char*szToAdd );

intAdd2( BTree*& Root,char*szToAdd );

voidPrintTree( BTree* btRoot );

intmain(intargc,char*argv[] ) {

// Usage message

if( argc < 2 ) {

cerr <<"Usage: Refptr [1 | 2]"<<"\n";

cerr <<"\nwhere:\n";

cerr <<"1 uses double indirection\n";

cerr <<"2 uses a reference to a pointer.\n";

cerr <<"\nInput is from stdin.\n";

return1;

}

char*szBuf =newchar[sizeOfBuffer];

if(szBuf == NULL) {

cerr <<"Out of memory!\n";

return-1;

}

// Read a text file from the standard input device and

// build a binary tree.

//while( !cin.eof() )

{

cin.get( szBuf, sizeOfBuffer,'\n');

cin.get();

if(strlen( szBuf ) ) {

switch( *argv[1] ) {

// Method 1: Use double indirection.

case'1':

Add1( &btRoot, szBuf );

break;

// Method 2: Use reference to a pointer.

case'2':

Add2( btRoot, szBuf );

break;

default:

cerr <<"Illegal value '"

<< *argv[1]

<<"' supplied for add method.\n"

<<"Choose 1 or 2.\n";

return-1;

}

}

}

// Display the sorted list.

PrintTree( btRoot );

}

// PrintTree: Display the binary tree in order.

voidPrintTree( BTree* MybtRoot ) {

// Traverse the left branch of the tree recursively.

if( btRoot->Left )

PrintTree( btRoot->Left );

// Print the current node.

cout << btRoot->szText <<"\n";

// Traverse the right branch of the tree recursively.

if( btRoot->Right )

PrintTree( btRoot->Right );

}

// Add1: Add a node to the binary tree.

// Uses double indirection.

intAdd1( BTree **Root,char*szToAdd ) {

if( (*Root) == 0 ) {

(*Root) =newBTree;

(*Root)->Left = 0;

(*Root)->Right = 0;

(*Root)->szText =newchar[strlen( szToAdd ) + 1];

strcpy_s((*Root)->szText, (strlen( szToAdd ) + 1), szToAdd );

return1;

}

else{

if(strcmp( (*Root)->szText, szToAdd ) > 0 )

returnAdd1( &((*Root)->Left), szToAdd );

else

returnAdd1( &((*Root)->Right), szToAdd );

}

}

// Add2: Add a node to the binary tree.

// Uses reference to pointer

intAdd2( BTree*& Root,char*szToAdd ) {

if( Root == 0 ) {

Root =newBTree;

Root->Left = 0;

Root->Right = 0;

Root->szText =newchar[strlen( szToAdd ) + 1];

strcpy_s( Root->szText, (strlen( szToAdd ) + 1), szToAdd );

return1;

}

else{

if(strcmp( Root->szText, szToAdd ) > 0 )

returnAdd2( Root->Left, szToAdd );

else

returnAdd2( Root->Right, szToAdd );

}

}