板凳——————————————————c++(5)

#include “AirlineTicket.h”

AirlineTicket::AirlineTicket() : mPassengerName(“Unknown Passager”),
mNumberOfMiles(0), mHasEliteSuperRewardsStatus(false){ }

AirlineTicket::~AirlineTicket()
{
}

double AirlineTicket::calculatePriceInDollars() const{
if(hasEliteSuperRewardsStatus()){
return 0;
}
return getNumberOfMiles() * 0.1;
}

const std::string& AirlineTicket::getPassengerName() const{
return mPassengerName;
}

void AirlineTicket::setPassengerName(const std::string& name){
mPassengerName = name;
}

int AirlineTicket::getNumberOfMiles() const{
return mNumberOfMiles;
}

void AirlineTicket::setNumberOfMiles(int miles) {
mNumberOfMiles = miles;
}

bool AirlineTicket::hasEliteSuperRewardsStatus() const{
return mHasEliteSuperRewardsStatus;
}

void AirlineTicket::setHasEliteSuperRewardsStatus(bool status) {
mHasEliteSuperRewardsStatus = status;
}

#include
#include
#include
#include
#include “AirlineTicket.cpp”
#include
void mysteryFunction( std::string * someString){ // 加const std::string *
*someString = “Test”; // will not compile!汇编，编辑， 编制， 编译
}

// void addOne(int i){
// i++; // Has no real effect because this is a copy of the original
// }

void addOne(int& i){
i++; // Actually changes the original variable
}
// p 25
void printString(const std::string& myString){
std::cout << myString << std::endl;
}

void uppercasify(std::string& str) //把str中所有的字符改成大写
{
for (std::string::size_type index = 0; index != str.size(); ++index)
std::cout << toupper(str[index]);
}
// p26
double divideNumbers(double numerator, double denominator){
if(denominator == 0){
throw std::invalid_argument(“Denominator cannot be 0.”);
}
return numerator / denominator;
}
//p28
class AirlineTicket{
public:
AirlineTicket();
~AirlineTicket();

double calculatePriceInDollars() const;
const std::string& getPassengerName() const;
void setPassengerName (const std::string& name);

int getNumberOfMiles() const;
void setNumberOfMiles(int miles);

bool hasEliteSuperRewardsStatus() const;
void setHasEliteSuperRewardsStatus(bool status);

private:
std::string mPassengerName;
int mNumberOfMiles;
bool mHasEliteSuperRewardsStatus;

};

// class std::invalid_argument:public logic_error {
// public:
// explicit invalid_argument (const std::string& what_arg);
// };

int main(int argc, char *argv[]){
std::string myString = “The string”;
mysteryFunction(&myString);
int myInt = 7;
addOne(myInt);
std::cout << myInt << std::endl;
std::cout << myString << std::endl;

std::string someString = "Hello world";
printString(someString);
printString("Hello world");

// //http://blog.sina.com.cn/s/blog_bde90b6601017n1u.html
// //例如一个函数，它用来计算一个字符在字符串中出现的次数：
// // 返回ch在str中出现的次数
// size_t countChar(const std::string str, char ch);
// //声明
// char buffer[MAX_STRING_LEN];
// char c;
// // 读入到一个字符和字符串中，用setw 避免缓冲溢出
// std::cin >> c >> setw(MAX_STRING_LEN) >> buffer;
// std::cout << "There are " << countChar(buffer, c)
// << " occurrences of the character " << c << " in " << buffer << std::endl;
// //对于countChar的调用，第一个被传递的参数是字符数组，但是对应函数需要的参数类型是const string。
// //仅当消除类型不匹配后，才能成功进行这个调用，你的编译器很乐意替你消除它，方法是建立一个string类型的临时对象。
// //通过以buffer做为参数调用string的构造函数来初始化这个临时对象。
// //countChar的参数str被绑定在这个临时的string对象上。当countChar返回时，临时对象自动释放。
// //从效率的观点来看，临时string对象的构造和释放是不必要的开销。
// char subtleBookPlug[] {“Effective C++”};
// uppercasify( subtleBookPlug ); // 错误!
// //假设建立一个临时对象，那么临时对象将被传递到upeercasify中，其会修改这个临时对象，把它的字符改成大写。
// //但是对subtleBookPlug函数调用的真正参数没有任何影响；仅仅改变了临时从subtleBookPlug生成的string对象。
// //无疑这不是程序员所希望的。程序员传递subtleBookPlug参数到uppercasify函数中，期望修改subtleBookPlug的。
// //当程序员期望修改非临时对象时，对非常量引用（references-to-non-const）进行的隐式类型转换却修改临时对象。
// //这就是为什么语言禁止为非常量引用（reference-to-non-const）产生临时对象。
// //这样非常量引用（reference-to-non-const）参数就不会遇到这种问题。

// //https://blog.csdn.net/liuxialong/article/details/6539717
// //临时对象的定义：
// //来看一个例子，在c++里，这个tmp是局部对象（变量），而不是临时对象
// template
// void swap(T &obj1, T&obj2){
// obj tmp = obj1;//这里的tmp不能被称为临时对象，它只是局部对象
// obj1 = obj2;
// obj2 = tmp;
// }
// //在C++中真正的临时对象是看不见的，它们不出现在你的源代码中。
// //建立一个没有命名的非堆（non-heap）对象会产生临时对象。
// //2、建立临时对象的第二种环境是函数返回对象时。
// //例如operator+必须返回一个对象，以表示它的两个操作数的和（参见Effective C++ 条款23）。
// //给定一个类型Number，这种类型的operator+被这样声明：
// const Number operator+(const Number& lhs, const Number& rhs);
// //这个函数的返回值是临时的，因为它没有被命名；它只是函数的返回值。
// //你必须为每次调用operator+构造和释放这个对象而付出代价。

         //std::invalid_argument应用        2020年04月19日 21时47分23秒 
         //https://www.cnblogs.com/couhujia/archive/2012/10/23/2735682.html
         //首先说明invalid_argument是一个类（class invalid_argument;），它的继承关系如下
         //exception-------->logic_error--------->invalid_argument   
         //invalid_argument顾名思义指无效参数，这个应该应用在检查参数是否是无效的，一般检查参数用于特定的函数以及类，那么就应该是给类的成员变量赋值或者函数参数赋值时，检查其赋给它们的值是否有效
         
         try{
            std::cout << divideNumbers(2.5, 0.5) << std::endl;
            std::cout << divideNumbers(2.3, 0) << std::endl;
            std::cout << divideNumbers(4.5, 2.5) << std::endl;
         }catch(const std::invalid_argument&  exception){ 
            std::cout << "Exception caught: " << exception.what() << std::endl;
         }
         //https://www.cnblogs.com/couhujia/archive/2012/10/23/2735682.html
         try {
            bool errorArgument;
                 errorArgument=true;
         if(errorArgument){
            throw std::invalid_argument("occur error!");
          }
           }catch(std::invalid_argument &ia){
             //what()为invalid_argument继承exception类的函数
            std::cerr<<" Invalid_argument "<< ia.what()<<std::endl;
          }
 
      AirlineTicket myTicket;
      myTicket.setPassengerName("Sherman T. Socketwrench");
      myTicket.setNumberOfMiles(700);
      double cost = myTicket.calculatePriceInDollars();
      std::cout << "This ticket will cost $ " << cost << std::endl;
      
      auto myTicket2 = std::make_unique<AirlineTicket>();
      myTicket2->setPassengerName("Laudimore M. Hallidue");
      myTicket2->setNumberOfMiles(2000);
      myTicket2->setHasEliteSuperRewardsStatus(true);
      double cost2 = myTicket2->calculatePriceInDollars();
      std::cout << "This other ticket will cost $" << cost2 << std::endl;
  return 0;

}
/*
wannian07@wannian07-PC:~$ ./c17
wannian07@wannian07-PC:~$ g++ -std=c++17 -o c17 c17.cpp
wannian07@wannian07-PC:~$ ./c17
8
Test
Hello world
Hello world
5
Exception caught: Denominator cannot be 0.
Invalid_argument occur error!
This ticket will cost $ 70
This other ticket will cost $0