C++ Primer Plus学习笔记

最新推荐文章于 2022-12-22 17:06:11 发布
最新推荐文章于 2022-12-22 17:06:11 发布
阅读量2.4k 收藏 3
点赞数
分类专栏： C++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/damotiansheng/article/details/39030849
版权

《C++ primer》第五版 第8-14章笔记

1. 宏替代

#include <iostream>
using namespace std;

#define SQUARE(X) ( (X) * (X) )

int main()
{
	int c = 3;
	// SQUARE(c++)将会被替代为( (c++) * (c++) ) 
	cout << SQUARE(c++) << endl;  //将输出9而不是12,将整个表达式计算完之后才递增 
	cout << c << endl;  // 输出5 
	cin.get();
	return 0;
}


2. 临时对象为const类型

double cube( double & x )
{
return x * x * x; 
} 
int main()
{
	double c = 3;
	cout << cube( c + 1.0 ) << endl; // 编译错误，c+1.0将产生一个临时对象，而临时
	// 对象在c++中都是const类型的，所以将cube的参数类型改为 const double & x即可 
	return 0;
}

注：1> 实参的类型正确，但不是左值；2> 实参的类型不正确，但可以转换为正确的类型；

    这两种情况下，编译器会生成临时对象。P231（c++ perimer第五版）

 

3. extern定义的变量

//test.cpp
#include <iostream>
using namespace std;
extern int num = 10; // 定义一个变量，外部链接，可以在其他文件中使用num

void show()
{
<span style="white-space:pre">	</span>cout << num << endl;
<span style="white-space:pre">	</span>cout << "hello world" << endl;
<span style="white-space:pre">	</span>return;
}
 
// test1.cpp
#include <iostream>
using namespace std;
extern int num;
extern void show();
int main()
{
<span style="white-space:pre">	</span>show();
<span style="white-space:pre">	</span>cout << num << endl;
<span style="white-space:pre">	</span>return 0;
}


4. const之前有无extern关键字的区别

例子1：
// 1.cpp    num链接性为内部，即只能在1.cpp中使用,这就是为什么可以在头文件中定义const常量，
//然后在其他文件包含该头文件而可以使用const常量
const int num = 0;  
void show()
{
	cout << num << endl;
	return;
}
// 若要使得num为外部变量，即在其他文件中也可以使用，则只需添加extern关键字即可，如下：
extern const int num = 20; // 其他文件中也可以使用num常量，外部链接，此处可以初始化（const数据必须初始化）
// 具体见P278 《c++ primer第五版》
 
例子2：
// test.cpp
#include <iostream>
using namespace std;
int num = 10; // 定义一个变量，外部链接，可以在其他文件中使用num
void show()
{
	cout << "hello world" << endl;
	return;
}
 
// test1.cpp
#include <iostream>
using namespace std;
// extern int num = 15; 错误，有extern并且初始化，相当于定义一个链接性为外部的变量，//即在其他文件中也可以使用此处定义的num常量，但是test.cpp中已经定义了num变量，//所以该处会出现重复定义的编译错误
extern int num;  // 正确的声明，表面num在其他文件中已经定义了
extern void show(); // 不需要extern也可以 具体见P278 《c++ primer第五版》
int main()
{
	show();
	cout << num << endl; // 输出10
	return 0;
}

5. 创建的类对象是否能调用构造函数

// 5. h 
#include <iostream> 
class Stock
{
private:
	int m_num;
public:
	void set();
	Stock();
};
// 6.cpp
#include "5.h"
using namespace std;
void Stock::set() // 前面添加inline则表示内联函数
{
	m_num = 2;
	std::cout << m_num << std::endl;
	return;
}
 
Stock::Stock()
{
	cout << "constructro called" << endl; 
}
 
// main.cpp
#include <cstdlib>
#include <iostream>
#include "5.h" 
using namespace std;
 
int main(int argc, char *argv[])
{
	Stock test;
	test.set();  
	test.Stock();  // 编译错误-》构造函数被用来创建对象，而不能通过对象来调用，见P310(C++ Primer第五版）
	system("PAUSE");
	return EXIT_SUCCESS;
}

6. P315 《C++ Primer第五版》

/
// Filename:Stock.h
/
#ifndef STOCK_H
#define STOCK_H
 
class Stock
{
private:
	char company[30];
	int shares;
	double share_val;
	double total_val;
	void set_tot()
	{
		total_val = shares * share_val;
		return;
	}
public:
	Stock();
	Stock( const char *co, int n, double pr = 0.0 );
	Stock( const char *pch );
	~Stock();
	void show();
};
#endif
 

/
// Filename:Stock.cpp

#include <iostream>
#include "Stock.h"
 
Stock::Stock()
{
	std::cout << "Default constructor called!\n";
	std::strcpy( company, "no name" );
	shares = 0;
	share_val = 0.0;
	total_val = 0.0;
}
 
Stock::Stock( const char *co, int n, double pr )
{
	std::cout << "Constructor using " << co << " called\n";
	std::strncpy( company, co, 29 );
	company[29] = '\0';
	if( n < 0 )
	{
		std::cerr << "Number of shares can not be negative; "
		<< company << " shares set to 0.\n";
		shares = 0; 
	}
	else
	{
		shares = n;
	}
	share_val = pr;
	set_tot(); 
}
 
Stock::Stock( const char *pch )
{
	std::cout << pch << std::endl;
	strcpy( company, pch );
}
 
Stock::~Stock()
{
	std::cout << "Bye, " << company << "!\n";
}
 
void Stock::show()
{
	using std::cout;
	using std::endl;
	cout << "Company: " << company << " Shares: " << shares << endl
	<< " Share Price: $" << share_val << " Total Worth: $" << total_val << endl;
	return;
}
 
/
// Filename:main.cpp
 
#include <iostream>
#include "Stock.h"
 
int main()
{
	using namespace std;
	{
		Stock stock1( "stock1", 12, 20.0 );
		cout << "\nstock1 show:" << endl;
		stock1.show();
		cout << endl;
		Stock stock2 = Stock( "stock2", 2, 2.0 ); // Dev-C++编译运行不会产生临时对象 
		cout << "stock2 show:" << endl;
		stock2.show();
		stock2 = stock1;
		cout << "\nstock1 show:" << endl;
		stock1.show();
		cout << "\nstock2 show:" << endl;
		stock2.show();
		cout << endl;
		stock1 = Stock( "temp stock", 10, 50.0 );// Dev-C++编译运行会产生临时对象，并将临时对象赋值给stock1
		stock1.show();
		cout << "Done\n";
		Stock stock3 = "hello stock3"; //  Dev-C++编译运行不会调用Stock( const char *pch )产生临时对象，然后赋值		为stock3，然后释放该临时对象，而是直接调用Stock( const char *pch )构造stock3对象
	}
	cin.get();
	return 0;
}

运行结果：



 

7.   临时对象，拷贝构造函数，析构函数的调用

#include <iostream>
class A
{
private:
	int num;
public:
	A( int n ):num(n)
	{
		std::cout << "constructor called " << num << std::endl;
	};
	A( const A &a ) // 拷贝构造函数
	{
		std::cout << "A( const A &a )'s &a " << &a << std::endl; 
		std::cout << "copy constructor called " << std::endl;
		std::cout << "A( const A &a )'s this:" << this << std::endl;
		this->num = a.num; // 类成员函数可以访问私有变量 
	} 
	~A()
	{
		std::cout << "~A()'s this:" << this << std::endl;
		std::cout << "destructor called " << num << std::endl;
	}
	void print()
	{
		std::cout << num << std::endl;
	}
};
 
A getA( A a )
{
	std::cout << "getA()'s &a:"  << &a << std::endl; 
	return a;
}
int main()
{
	using namespace std;
	{
		A x(20); // 构造函数输出 
		cout << "main:&x: " << &x << endl;
		getA(x).print(); 
	}
	cin.get();
	return 0;
} 
 
/*
getA(x).print(); 执行流程：
1. 调用类A的拷贝构造函数，传实参x传给拷贝构造函数，用来构造getA函数中的对象a ;
2. getA函数返回时也会调用拷贝构造函数，传实参a给拷贝构造函数，用来在函数外部构造一个临时对象;
3. 临时对象调用成员函数print();
4. 临时对象调用析构函数并释放空间;
5. getA函数中的局部对象a调用析构函数并释放空间;
6. main函数中的对象x调用析构函数并释放空间.
*/

/*

输出结果：

 

*/ 

 

8. 转换函数 P367《C++ Primer第五版》,赋值函数

#include <iostream>
 
class A
{
private:
	int n;
public:
	A( int nn):n(nn)
	{
		std::cout << "constructor called: " << n << std::endl;
	}
	~A()
	{
		std::cout << "destructor called: " << n << std::endl;
	}
	A& operator=( const A &t ) // 赋值函数 
	{
		std::cout << "assign function called" << std::endl;
		A::n = t.n;// 用A::n也行 
		// this->n = t.n;
	} 
	operator int()// 转换函数，将A对象转换为int类型 
	{
		return n;
	}
};
 
int main()
{
	using namespace std;
	{ 
		A a = 2; // 会调用 A( int nn),不会先构造临时对象，而是直接调用A( int nn)构造对象a 
		a = 3;  // 会先调用 A( int nn)构造临时对象，然后将临时对象赋值给a，完成后，临时对象释放 
		cout << a << endl; // 将调用转换函数，从而将A类型转换为int类型
		cout << (int)a << endl; // 也会调用转换函数
	} 
 
	cin.get();
	return 0;
} 
/*
输出结果：
constructor called: 2
constructor called: 3
assign function called
destructor called: 3
3
3
destructor called: 3
*/


9. 返回值对象，拷贝构造函数，编译器优化

#include <iostream>
 
class A
{
private:
	int num;
public:
	A( int n ):num(n)
	{
		std::cout << "constructor called: " << n << std::endl;
	}
	~A()
	{
		std::cout << "destructor called: " << num << std::endl;
	}
	A( const A &a )
	{
		std::cout << "copy constructor called\n";
		this->num = a.num;
	}
	A& operator=( const A &a ) // 赋值操作符函数 
	{
		std::cout << "= function called\n";
		this->num = a.num;
	}
	friend std::ostream& operator<<( std::ostream &os, const A &a )
	{
		return os << a.num;
	}
};
 
	A getA( int num )
	{
		A a(num);
		std::cout << &a << std::endl;
		return a;
	}
 
int main()
{
	using namespace std;
	{
		A a1 = getA(1); // 不会调用拷贝构造函数，getA函数中直接在外部创建对象a1 
		// 而不会在getA函数中先创建对象a，然后调用拷贝构造函数构造a1，这里
		//编译器优化了，直接在外部创建对象a1了，并初始化为1，故getA函数结束时
		// 不会释放a了，因为此次调用没有在函数getA中创建局部变量a，而是直接在外部
		// 创建对象a1了 
		cout << &a1 << endl;
		cout << a1 << endl;
		A a2(4);  
		a2 = getA(2); // 这里是赋值，故在getA()中创建对象a，然后
   		 // 调用赋值函数，赋值给a2，然后释放函数getA中的对象a 
		cout << a2 << endl;
	}
	cin.get();
	return 0;
}
 
/*
输出结果：
constructor called: 1
0x22ff20
0x22ff20
1
constructor called: 4
constructor called: 2
0x22ff00
= function called
destructor called: 2  // 释放getA(2)调用中的对象a 
2
destructor called: 2  // 释放对象a2 
destructor called: 1 // 释放对象a1 
*/

 

 

10. P484《C++ primer中文第五版》

#include <iostream>
#include <string>
#include <valarray>
using namespace std;
 
class Student
{
private:
	typedef valarray<double> ArrayDb;
	ArrayDb scores;
	string name;
public:
	Student( int n ):name("Nully"), scores(n) // scores初始化为n个元素 
	{
	}
	double& operator[]( int i ) // 函数1 去掉&也能编译通过 
	{
		cout << "operator[](int i) called\n";
		return scores[i];
	}
	double operator[]( int i ) const //该函数与函数1是不同的函数，为函数重载 
	{
		cout << "operator[](int i) const called\n";
		return scores[i];
	}
	friend istream& operator>>( istream &is, Student &stu )
	{
		cout << "operator>> function called\n";
		is >> stu.name;
		return is;
	}
}; 
 
int get()
{
	int result = 9;
	return result;
} 
 
int main()
{
	// cin >> get(); 编译不通过 ..................1 
	Student stu(1);
	cin >> stu;   // 调用operator>> 
	cin >> stu[0];  // 调用double& operator[]( int i ),而不是double operator[]( int i ) 
               // 若只有 double operator[]( int i ) 则会编译有错,类似上面的cin>>get() 
   	 cout << stu[0] << endl; // dev-C++中调用double& operator[]( int i ) 
	system("pause");
	return 0;
}
//注：函数后面加const与不加const是不同的，可以因为这一区别而完成函数重载


 

 

 

 

damotiansheng
关注
专栏目录
C++ Primer Plus 学习笔记（函数）（一）
HenryFeng1008的博客
08-06 911
1. 基本知识 使用 C++ 函数，必须完成以下工作： 提供函数定义 提供函数原型 调用函数 库函数是已经定义和编译好的函数，同时可以使用标准库头文件提供其原型，因此只需正确地调用这种函数即可。 1. 1 定义函数 可以将函数分成两类：没有返回值的函数和有返回值的函数。没有返回值的函数被称为 void 函数，其通用格式如下: void functionName (paramet...
C++ Primer Plus 学习笔记（一）
m0_51155852的博客
11-02 730
第二章. 开始学习C++ 1. 主函数 int main() 等效于 int main(void) 即空括号等效于不接受参数。main函数相当于程序与系统的接口，可以看作返回值给操作系统并不给程序，区分大小写大小写。 2. 预处理器 与 C 不同，C++风格的头文件没有拓展名，即没有 .h 后缀，如 iostream。 命名空间如： using namespace std; 使用using编译指令，可以更明确的指示所使用的变量或函数等属于哪。也可以只是用命名空间的某些元素，如： ..
《c++ primer plus》学习笔记
shawnrong的专栏
10-17 954
1. .h文件要用#ifndef-#endif包住，.cpp开头要有using namespace std声明；2. class命名首字母大写，成员变量应当以m_开头；3. 如果class成员函数没有改变成员变量的值，应当声明为const函数；4. 定义对象时候最好用ClassA a(...);而避免ClassA a=ClassA(...)，省得多创建临时变量；5. 一般只有返回值为指针的函数会给
C++ primer plus_学习笔记
LYY_WJL的博客
12-10 546
C++ primer plus 复习笔记（第二遍复习）
<C++ primer plus>学习笔记
u014575071的博客
12-15 271
第一章  预备知识  C++真正的优点之一：可以方便地重用和修改现有的、经过仔细测试的代码。  C++融合了OOP、泛型编程和传统过程性方法。    程序创建的方法：  1、编写程序      2、编译源代码    3、将目标代码与其他代码连接起来。 windows 编译器     第二章 开始学习C++
C++ Primer Plus 学习笔记
最新发布
04-17
《C++ Primer Plus 学习笔记》是一份深入学习C++编程语言的宝贵资源，它涵盖了C++的基础语法以及标准模板库（STL）的使用。C++是一种强大的、通用的编程语言，由Bjarne Stroustrup在C语言的基础上发展而来，其设计...
C++Primer Plus学习笔记（三）
09-02
C++ primer plus学习笔记之三，分为一下几个部分： 函数参数：介绍了函数的生命规则以及定义 数组函数：数组作为变量时的使用方法 指针和const：灵活运用指针和const 函数和二维数组:二维数组作为变量时声明以及定义...
C++Primer Plus学习笔记（四）
09-02
第八章函数探幽 内联函数 默认参数 函数重载 函数模板
C++ Primer Plus学习笔记之二
09-01
C++ Primer Plus 第六章分支语句和逻辑操作符的笔记 用例子阐释了 逻辑表达式，问号操作符，switch语句，break和continue以及文件简单输入输出 学习笔记系列博客地址：...
C++Primer Plus学习笔记（五）
09-03
C++ Primer Plus 第9章内存模型和名称空间 new操作符以及名称空间的使用demo
C++ primer plus 学习笔记
无
03-11 702
.h文件为老式头文件，没有.h扩展名需要using namespace 声明变量:需要的内存以及该单元的名称 C++11 int n = {1}; 初始化 A 65 a 97 wchar_t 扩展字符集 ,是一种整数类型,wcout处理宽字符流 用const 比define好,可以使用C++ 作用域规则将定义限制在特定的函数或者文件中 未完待续
C++ Primer plus 学习笔记
m0_37731749的博客
02-28 437
C++应该算是我的第二语言，做过一个相关项目，学习书籍是《C++ primer plus》蓝色的那一版本我把我认为容易忘记的一些点就记录在这里了。都是基础，适合新手C++ x++先执行x再执行++，++x先执行++再执行x。++x比x++运行速度快，因为x++需要先创建一个x的副本。 #include “ ”在当前目录底下寻找头文件，若没有再去标准位置查找；#include&lt;&gt;在标准...
C++ primer plus——学习笔记
LYY_WJL的博客
12-22 465
C++ primer plus
c++ primer plus学习笔记01
baidu_41553551的博客
05-31 1489
简介 oop(面向对象编程) oop的本质是设计并扩展自己的数据类型。 泛型编程和oop一样都会使的重用代码和抽象通用概念更加简单， oop强调的是编程的数据方面 泛型强调的是对立于特定的数据类型 类定义描述的是数据格式及用法，对象是根据数据格式规范创建的实体。 类描述指定了可对类对象执行的所有操作，要对特定对象执行这些允许的操作，有两种方法， 第一种就是函数的定义 第二种就是重新定义运算符 UNIX编译和链接 .c ->.o(目标代码文件)->.out(代码和库文件结合起来形
C++ primer plus学习笔记(一)——基础语法
weixin_44627989的博客
03-26 526
本来是java方向的程序员，因为部门语言需要最近开始学习cpp,刚看到C++ primer plus这本书的第10章，在进入cpp的面向对象学习前，先整理下前面9章的知识笔记，以下内容基于c++11标准 指针与&、* &在c++中的一种作用为取出当前变量在内存的逻辑地址 *在c++中的一种作用为取出当前逻辑地址对应的内存空间的值 c++中提供指针变量存储对象的地址，指针的运算会被编...
c++ primer plus学习笔记
小可爱的博客
07-21 866
预备知识 c++在c语言的基础上添加了面向对象编程和泛型编程 c语言诞生的背景：贝尔实验室开发UNIX操作系统，需要一种高级语言代替汇编语言，避免在每台计算机上执行不同的汇编程序 c语言编程的原理（强调的是算法） 需要处理的概念——数据和算法 结构化编程和自顶向下的编程方法，将程序不断划分成程序单元，便于阅读和管理 面向对象编程： 面向对象编程强调数据，用类描述特定的数据...
《C++ Primer Plus》学习笔记
Matrix
10-19 226
C++ Primer Plus 第六版 第一章 预备知识 主要有三个点： C++在C的基础上添加了面向对象编程（OOP）和泛型编程，前者更倾向于数据，后者则是独立于类型，提供了执行常见任务的工具； C++源代码需要经过编译、链接两个步骤才得到最终的可执行代码。编译是将源代码转成机器能理解的目标代码（object code），该过程由编译器完成，Windows一般是Microsoft Visual C++ 2010，Linux一般是g++，MacOS一般是clang；链接是将目标代码同使用的函数的目标代码以
C++ Primer Plus学习笔记（一）
qq_33586075的博客
06-28 271
第二章 开始学习C++ 2.1 一个简单的开始本节示例代码：C++//myfrist.cpp#include <iostream>int main(){ using namespace std; cout<<"Hello"; cout<<endl; cout<<"World"<<endl; cin.get(); //也可用system("pause"); return 0; //可以不写，但没必要} 1. 如何阻止程序“闪退”可以用system(“
C++ Primer Plus 学习笔记（数据处理）
HenryFeng1008的博客
07-26 637
1. 简单变量 1. 1 变量名命名规则： 在名称中只能使用字母字符、数字和下划线（_）。 名称的第一个字符不能是数字。 区分大写字符与小写字符。 不能将C++关键字用作名称。 以两个下划线或者下划线和大写字母打头的名称被保留给实现使用。 C++对于名称的长度没有限制，名称中的所有字符都有意义，但有些平台有长度限制。 常用命名前缀有：str 或 sz（表示以空字符结束的字符串...
C++ Primer Plus 学习笔记：从入门到精通
"《C++ Prime Plus》是Stephen Prata所著的一本C++入门教程，这本图书的自学总结笔记全面涵盖了C++的基础概念、语法以及编程实践。笔记包含了可运行的代码示例，适合初学者高效学习C++。笔记内容详实，包括作者自创...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值