Note04

最新推荐文章于 2024-03-06 22:42:04 发布

David_Hernandez

最新推荐文章于 2024-03-06 22:42:04 发布

阅读量308

点赞数

分类专栏： C++

本文链接：https://blog.csdn.net/kisslotus/article/details/54428056

版权

C++ 专栏收录该内容

11 篇文章 0 订阅

订阅专栏

书：C++大学教程（第七版）
1. cmath头文件提供了能够进行通用数学计算的函数集合。
这里写图片描述
2. 数据类型

3. 标准库头文件

4. rand函数的原型在中
5. srand()和rand()
srand()就是给rand()提供种子seed，通常将时间作为种子；
srand(time(0));
如果srand每次输入的数值是一样的，那么每次运行产生的随机数也是一样的

srand( (unsigned)time( NULL ) ); 
/* Display 10 numbers. */ 
for( i = 0; i < 10;i++ ) 
    printf( " %6d/n", rand() ); 
}

#include <iostream>
#include <cstdlib>
#include <ctime>
using namespace std;
int main()
{
    srand(time(0));
    for (size_t i = 0; i < 100; i++)
    {
        if (i > 0 && i % 5 == 0)
        {
            cout << endl;
        }
        cout << rand()<<"\t";
    }
    system("pause");
    return 0;
}

递归和迭代
迭代使用循环结构，递归使用选择结构；迭代显示地使用循环结构，递归通过重复的函数调用实现循环；
将指针传递给函数的4种方式：
（1）指向非常量数据的非常量指针：具有最大的访问权限，如：int *countPtr；
（2）指向常量数据的非常量指针：可以被修改以指向任何适当类型的其他数据项，但是不能通过该指针来修改它所指向的数据。可以用这种指针为函数接收数组实参，函数处理数组的每个元素，但不允许修改数据。形如：const int *countPtr；从右到左读作“countPtr是指向一个字符常量的指针”
（3）指向非常量数据的常量指针：始终指向同一个内存位置，通过该指针可以修改这个位置上的数据。这就是数组名的默认情况，数组名是指向这个数组开始处的常量指针。使用数组名和数组下标，可以访问和修改数组中的所有元素。可以用来接收数组作为函数的实参，在函数中用数组下标表示法访问数组元素。声明为const的指针在声明时必须被初始化，如果指针是函数参数，他被传递给函数的指针初始化。形如：int * const ptr = &x;
（4）指向常量数据的常量指针：具有最小的访问权限。这种指针总是指向内存中相同的位置，并且不能用该指针修改这个内存位置的数据。如果函数接收一个数组做参数，只是用数组下标表示法读取数组而不修改数组，那么应该用这种指针。形如：const int * const ptr = &x;从右大左读作“ptrr是指向一个整数常量的常量指针”。当试图修改ptr指向的数据和存储在该指针变量中的地址时，产生错误信息。注意：当程序试图间接引用ptr，或当程序试图输出ptr所指向的值时，不会发生错误。
数组名是常量指针，总是指向数组的开头。如：b += 3；将引起错误；

int b[5];
int *bPtr;
bPtr = b;//等价于bPtr = &b[0];

第三个元素的值： *(b+2)
9. 函数指针

bool (* compare ) (int , int )

关键字bool表示所指向的函数返回一个bool值。文本(*compare)表示函数指针的名字（此处的*表明参数compare是一个指针）。文本（int，int）表示compare所指向的函数有两个整型参数。*compare的两边要加上圆括号，才能表示compare是一个函数指针。如果不加圆括号，该声明将变成下述形式：

bool * compare(int, int )

那么它表示一个接受两个整数做参数、并返回一个指向bool值的指针的函数。

(*compare)( work[ smallestOrLargest ], work[ index ] )

就想简介引用变量指针可以访问变量值一样，简介引用函数指针可以执行该函数。*compare两边的圆括号是必须的，如果没有，*运算符试图间接引用函数调用所返回的值。不间接引用函数指针，也可以调用该函数，如下所示：

compare( work[ smallestOrLargest ], work[ index ] )

这里将指针直接作为函数名使用。提倡通过指针调用函数的第一种方法，因为他显示地说明compare是一个函数指针，通过间接引用这个指针来调用函数。通过指针调用函数的第二种犯法使compare看起来好像是程序中的一个实际函数的名字。这会使程序的用户感到迷惑，他想看函数compare的定义，但却发现在文件中它并没有被定义。

// Multipurpose sorting program using function pointers.
#include <iostream>
#include <iomanip>
using namespace std;
// prototypes
void selectionSort( int [], const int, bool (*)( int, int ) );
void swap( int * const, int * const );   
bool ascending( int, int ); // implements ascending order
bool descending( int, int ); // implements descending order
int main()
{
   const int arraySize = 10;
   int order; // 1 = ascending, 2 = descending
   int counter; // array index
   int a[ arraySize ] = { 2, 6, 4, 8, 10, 12, 89, 68, 45, 37 };
   cout << "Enter 1 to sort in ascending order,\n" 
      << "Enter 2 to sort in descending order: ";
   cin >> order;
   cout << "\nData items in original order\n";

   // output original array
   for ( counter = 0; counter < arraySize; counter++ )
      cout << setw( 4 ) << a[ counter ];
   // sort array in ascending order; pass function ascending 
   // as an argument to specify ascending sorting order
   if ( order == 1 ) 
   {
      selectionSort( a, arraySize, ascending );
      cout << "\nData items in ascending order\n";
   } // end if
   // sort array in descending order; pass function descending
   // as an argument to specify descending sorting order
   else 
   {
      selectionSort( a, arraySize, descending );
      cout << "\nData items in descending order\n";
   } // end else part of if...else
   // output sorted array
   for ( counter = 0; counter < arraySize; counter++ )
      cout << setw( 4 ) << a[ counter ];
   cout << endl;
} // end main
// multipurpose selection sort; the parameter compare is a pointer to
// the comparison function that determines the sorting order
void selectionSort( int work[], const int size,
                    bool (*compare)( int, int ) )
{
   int smallestOrLargest; // index of smallest (or largest) element
   // loop over size - 1 elements
   for ( int i = 0; i < size - 1; i++ )
   {
      smallestOrLargest = i; // first index of remaining vector
      // loop to find index of smallest (or largest) element
      for ( int index = i + 1; index < size; index++ )
         if ( !(*compare)( work[ smallestOrLargest ], work[ index ] ) )
            smallestOrLargest = index;
      swap( &work[ smallestOrLargest ], &work[ i ] );
   } // end if
} // end function selectionSort
// swap values at memory locations to which 
// element1Ptr and element2Ptr point
void swap( int * const element1Ptr, int * const element2Ptr )
{
   int hold = *element1Ptr;
   *element1Ptr = *element2Ptr;
   *element2Ptr = hold;
} // end function swap
// determine whether element a is less than 
// element b for an ascending order sort
bool ascending( int a, int b )
{
   return a < b; // returns true if a is less than b
} // end function ascending
// determine whether element a is greater than 
// element b for a descending order sort
bool descending( int a, int b )
{
   return a > b; // returns true if a is greater than b
} // end function descending

const
（1）对于const对象，不允许进行成员函数的调用，除非成员函数本身也声明为const。这一点非常严格，即使是不修改对象的获取对象函数也不行。
（2）不为const数据成员提供相应地成员初始化器是一个编译错误。
Friend
（1）类的friend函数（友元函数）在类的作用域之外定义，却具有访问类的非public（以及public）成员的权限。单独的函数或整个类都已被声明为另一个类的友元。
（2）使用friend函数可以提高程序的性能。
（3）友元声明可以出现在类的任何地方。
多种格式输出日期
格式：
DDD YYYY
MM/DD/YYYY
June 14, 1992
Date.h

#ifndef DATE_H
#define DATE_H
#include <string>
using namespace std;
class Date 
{
public:
   Date(); // default constructor uses <ctime> functions to set date
   Date( int, int ); // constructor using ddd yyyy format
   Date( int, int, int ); // constructor using dd/mm/yy format
   Date( string, int, int ); // constructor using Month dd, yyyy format
   void setDay( int ); // set the day
   void setMonth( int ); // set the month
   void print() const; // print date in month/day/year format
   void printDDDYYYY() const; // print date in ddd yyyy format
   void printMMDDYY() const; // print date in mm/dd/yy format
   void printMonthDDYYYY() const; // print date in Month dd, yyyy format
   ~Date(); // provided to confirm destruction order
private:
   int month; // 1-12 (January-December)
   int day; // 1-31 based on month
   int year; // any year
   // utility functions 
   int checkDay( int ) const; // check if day is proper for month and year 
   int daysInMonth( int ) const; // returns number of days in given month
   bool isLeapYear() const; // indicates whether date is in a leap year
   int convertDDToDDD() const; // get 3-digit day based on month and day
   void setMMDDFromDDD( int ); // set month and day based on 3-digit day
   string convertMMToMonth( int ) const; // convert mm to month name
   void setMMFromMonth( string ); // convert month name to mm 
   int convertYYYYToYY() const; // get 2-digit year based on 4-digit year
   void setYYYYFromYY( int ); // set year based on 2-digit year
}; // end class Date
#endif

Date.cpp

#include <iostream>
#include <iomanip>
#include <ctime>
#include "Date.h" // include Date class definition
using namespace std;
// default constructor that sets date using <ctime> functions
Date::Date()
{
   // pointer of type struct tm which holds calendar time components
   struct tm *ptr; 
   time_t t = time( 0 ); // determine current calendar time      

   // convert current calendar time pointed to by t into
   // broken down time and assign it to ptr
   ptr = localtime( &t ); 

   day = ptr->tm_mday; // broken down day of month
   month = 1 + ptr->tm_mon; // broken down month since January
   year = ptr->tm_year + 1900; // broken down year since 1900
} // end Date constructor
// constructor that takes date in ddd yyyy format
Date::Date( int ddd, int yyyy )
{
   year = yyyy; // could validate
   setMMDDFromDDD( ddd ); // set month and day based on ddd
} // end Date constructor
// constructor that takes date in mm/dd/yy format
Date::Date( int mm, int dd, int yy )
{
   setYYYYFromYY( yy ); // set 4-digit year based on yy
   setMonth( mm ); // validate and set the month
   setDay( dd ); // validate and set the day
} // end Date constructor
// constructor that takes date in Month dd, yyyy format
Date::Date( string monthName, int dd, int yyyy )
{ 
   setMMFromMonth( monthName ); // set month based on month name
   setDay( dd ); // validate and set the day
   year = yyyy; // could validate
} // end Date constructor
// validate and store the day
void Date::setDay( int d )
{
   day = checkDay( d ); // validate the day
} // end function setDay
// validate and store the month
void Date::setMonth( int m )
{
   if ( m > 0 && m <= 12 ) // validate the month
      month = m;
   else 
   {                     
      month = 1; // invalid month set to 1
      cout << "Invalid month (" << m << ") set to 1.\n";
   } // end else
} // end function setMonth
// print Date object in form: month/day/year
void Date::print() const
{
   cout << month << '/' << day << '/' << year << endl; 
} // end function print
// print Date object in form: ddd yyyy
void Date::printDDDYYYY() const
{
   cout << convertDDToDDD() << ' ' << year << endl;
} // end function printDDDYYYY
// print Date object in form: mm/dd/yy
void Date::printMMDDYY() const
{
   cout << setw( 2 ) << setfill( '0' ) << month << '/' 
      << setw( 2 ) << setfill( '0' ) << day << '/' 
      << setw( 2 ) << setfill( '0' ) << convertYYYYToYY() << endl;
} // end function printMMDDYY
// print Date object in form: Month dd, yyyy
void Date::printMonthDDYYYY() const
{
   cout << convertMMToMonth( month ) << ' ' << day << ", " << year 
      << endl;
} // end function printMonthDDYYYY
// output Date object to show when its destructor is called
Date::~Date()
{ 
   cout << "Date object destructor for date ";
   print();
   cout << endl;
} // end ~Date destructor
// utility function to confirm proper day value based on 
// month and year; handles leap years, too
int Date::checkDay( int testDay ) const
{
   // determine whether testDay is valid for specified month
   if ( testDay > 0 && testDay <= daysInMonth( month ) )
      return testDay;
   // February 29 check for leap year 
   if ( month == 2 && testDay == 29 && isLeapYear() )
      return testDay;
   cout << "Invalid day (" << testDay << ") set to 1.\n";
   return 1; // leave object in consistent state if bad value
} // end function checkDay
// return the number of days in a month
int Date::daysInMonth( int m ) const
{
   if ( isLeapYear() && m == 2 )
      return 29;

   static const int daysPerMonth[ 13 ] = 
      { 0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };
   return daysPerMonth[ m ];
} // end function daysInMonth
// test for a leap year
bool Date::isLeapYear() const
{
   if ( year % 400 == 0 || ( year % 4 == 0 && year % 100 != 0 ) )
      return true;
   else
      return false;
} // end function isLeapYear
// calculate 3-digit day based on Date object's current month and day
int Date::convertDDToDDD() const
{
   int ddd = 0;
   // for each month that has passed, add days to ddd
   for ( int i = 1; i < month; i++ )
      ddd += daysInMonth( i );

   // add days from current month
   ddd += day;
   return ddd;
} // end function convertDDToDDD
// set month and day based on 3-digit day
void Date::setMMDDFromDDD( int ddd )
{
   int dayTotal = 0;
   int m;
   for ( m = 1; m <= 12 && ( dayTotal + daysInMonth( m ) ) < ddd; m++ )
      dayTotal += daysInMonth( m );
   setMonth( m );
   setDay( ddd - dayTotal );
} // end function setMMDDFromDDD

// utility function to convert month number to month name
string Date::convertMMToMonth( int mm ) const
{
   static const string months[] = 
      { "", "January", "February", "March", "April", "May", "June", 
      "July", "August", "September", "October", "November", "December" };
   return months[ mm ];
} // end function convertMMToMonth
// set month number based on month name    
void Date::setMMFromMonth( string m )
{
   bool matchFound = false;
   // loop for each month, checking for a match
   for ( int i = 1; i <= 12 && !matchFound; i++ )
   {
      string tempMonth = convertMMToMonth( i );
      if ( tempMonth == m )
      {
         setMonth( i );
         matchFound = true;
      } // end if
   } // end for
   if ( !matchFound )
   {
      cout << "Invalid month name (" << month << "). month set to 1.\n";
      setMonth( 1 ); // leave object in consistent state if bad value
   } // end if
} // end function setMMFromMonth
// utility function to convert 4-digit year to 2-digit year
int Date::convertYYYYToYY() const
{
   // if year is in 2000s, subtract 2000
   // else, assume year is in the 1900s and subtract 1900
   return ( year >= 2000 ? year - 2000 : year - 1900 );
} // end function convertYYYYtoYY
// utility function to convert 2-digit year to 4-digit year
void Date::setYYYYFromYY( int yy )
{
   // if yy is less than 7, assume it is in the 2000s
   // if yy is greater than or equal to 7, assume it's in the 1900s
   year = ( yy < 7 ? yy + 2000 : yy + 1900 );
} // end function setYYYYFromYY

Main

#include <iostream> 
#include "Date.h" // include Date class definition
using namespace std;
int main()
{
   Date date1( 256, 1999 ); // initialize using ddd yyyy format
   Date date2( 3, 25, 04 ); // initialize using mm/dd/yy format
   Date date3( "September", 1, 2000 ); // "month" dd, yyyy format
   Date date4; // initialize to current date with default constructor
   // print Date objects in default format
   date1.print();
   date2.print();
   date3.print();
   date4.print();
   cout << '\n';
   // print Date objects in 'ddd yyyy' format
   date1.printDDDYYYY(); 
   date2.printDDDYYYY();
   date3.printDDDYYYY();
   date4.printDDDYYYY();
   cout << '\n';
   // print Date objects in 'mm/dd/yy' format
   date1.printMMDDYY(); 
   date2.printMMDDYY();
   date3.printMMDDYY();
   date4.printMMDDYY();
   cout << '\n';
   // print Date objects in '"month" d, yyyy' format
   date1.printMonthDDYYYY();
   date2.printMonthDDYYYY();
   date3.printMonthDDYYYY();
   date4.printMonthDDYYYY();
   cout << endl;
} // end main

David_Hernandez

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
Note04

书：C++大学教程（第七版） 1. cmath头文件提供了能够进行通用数学计算的函数集合。 2. 数据类型 3. 标准库头文件 4. rand函数的原型在中 5. srand()和rand() srand()就是给rand()提供种子seed，通常将时间作为种子； srand(time(0)); 如果srand每次输入的数值是一样的，那么每次
复制链接

扫一扫