1.结构体&共用体
- 结构体能存储int,double和long;共用体能存储int,double或long
union perval{
double double_val;
int int_val;
};
perval per; //初始化union,c++中可不加union类型 c:union perval per;
per.int_val=15;
cout<<per.int_val;
per.double_val=15.0;
cout<<per.duouble_val;
struct parval{
double double_val;
int int_val;
}parr; //也可放末尾初始化
parr={1.0,1}; //初始化赋值
parval par; //初始化struct,c++中可不加struct
par.double_val=15.0;
par.int_val=15;
c++通用模板template class<>https://blog.csdn.net/lv0918_qian/article/details/81565654
结构体数组指针——指向结构体数组
student * creat(int n) //1.形式是指针
{
student * data = new student [n]; //指针
return data; //2.实参.return 指针,相当于return结构体数组
}
student * input (student * data,int n) //3.形参
{
for (int i=0;i<n;i++)
{
cin>>data[i].num>>data[i].name; //4. .............,不是->
2.a++&++a
++a,a++——>a=a+1;
单独用效果一样
a++;
++a;
赋值用
b=a++; //先将a赋给b,再+1;
(b=a+1)
b=++a; //a先+1,再赋值给b
(b=a)
3.访问std的四种方式
没啥问题用最快捷的using namespace std;
、
4.cout输出八进制,二进制,十六进制
cout<<hex<<a<<endl; //在变量前加hex、oct
5.const
学会习惯用const;(优点:https://blog.csdn.net/weibo1230123/article/details/81981384)a
关键字const修饰一个变量用于定义常量或参数,提高代码健壮性。
应用
- 为了防止调用对象被修改,类内方法定义时
有参数的将参数声明为const引用或指向const的指针,eg:
引用传递:
Stock::Stock(const string &co);
指针传递:
Stock::Stock(const string *fname);
无形参:
void Stock::show const();
- const int *p=&a; // 指针对象内容不能变 (变量内容,可以更改地址) ;int * const p=&a; //指针指向的对象不能变(地址,可以更改内容) (指针常量:* const,常量指针:const *)
使用const原因:
static(12.1)
静态数据成员static在类中使用需要注意:
声明格式:static int/char/double/... a; 需要在类中声明,但并未给分配内存,不可以在类中初始化(整型&const除外),需要类外初始化。
初始化格式:int/string/.../ 类名:: 变量名=0; 需要作用域,不需要static关键字。初始化位置不要在类声明文件(头文件),容易产生副本。
类中声明的static成员,类的对象们共用一个静态变量。
6.程序中写的小数默认为double型,要float小数后加f或F,1.23f
7.字符串string(这个用多了是毛病)
字符指针与字符串:https://blog.csdn.net/mensaochun/article/details/52786539
初始化
(首选)std::string str="cat"; //可以对其数组操作,str[2]
char a[4]={'c','a','t','\0'}; //一定要有\0,4可省略
char b[4]="cat"; //有\0
c版字符串需要\0
打印字符串:
std::string str1="abc";
std::string str;
cin>>str; //输入字符串;
cout<<str1;
cout<<str[0]<<str[1];
printf("%s",str.c_str());
注意:
- c中没有string..c++支持c风格字符串(char[]);使用c版字符串函数调用<cstring>
- c++使用string需要调用<string>;加作用域std::string
- string可以cin、cout、可以str1+str2(str1="cat";str2="log";str1+str2="catlog")
string其他操作见4.3.3
8.vector&array
- vector对象长度初始化可以用整型常量或整型变量;array必须常量
- vector对象存储在自由存储区或堆,array存在栈中
- vector[]和.at:at有检查索引越界功能,代价是运行时间
9.函数指针(指向函数的指针,中心在后)
double pem(int a);
double (*pf)(int a);
pf=pem;
a=pem(t);
a=(*pf)(t);
int tem(double (*pf)(int a)) //形参
{
}
tem(pem); //实参
double pem(int a)
形参:double (*pf)(int a) //将函数名换成*pf
实参:pem(函数名)
- 写下函数初始化,将函数名替换为(*名字)就是形参,函数名是实参;
- 必须加(),它的优先级要高于*; double *pf() 是return一个指针,double (*pf)()是函数指针
10.引用传递、指针传递、值传递
c支持后两者,c++支持三者
引用和指针传递两者区别不大,https://bbs.csdn.net/topics/360144769讨论的;
引用传递
int rats;
int &rodents=rats;
两者指向相同的地址和值,孰变皆变
指针传递
int rats;
int *rodent=&rats; //rodent=&rats
rodent指向rats的地址,孰变皆变
函数调用
int b;
int pem(int *a);
int pam(int &a);
pem(&b);
pem(b);
11.变量存储方式
- 编译器使用三块独立的内存:静态变量、自动变量、动态变量(区别在于保存在内存中的时间)
自动变量储存在栈中(LIFO)(局部变量、register、auto)
静态变量、动态变量(new)在堆中(和下面截图有些矛盾,它说静态变量存在静态存储区)
自动存储持续性:出了作用域就被释放。在程序开始执行所属代码块或函数时开始,到执行完释放。
静态存储持续性:static在程序整个运行过程中都存在。默认初始化为0.
动态存储持续性:生于new,死于delete。
(c++11)线性存储持续性:生命周期和所属线程一样长。
- 堆中内存都不受作用域限制,动态和静态区别是动态可以释放(c++ new&delete,c malloc&free)
- 看看吧,我还没看懂..
静态分配和动态分配
12.方法
- 类外方法
(错误)加inline ,原本类内也写为void Stock::set_tot(),省略了Stock::作用域
- 区分构造函数形参和类属性方法
构造函数的参数是赋给类成员的,为了避免混淆,可对其一添加前缀或后缀:
- 综合应用
//stock.h
#ifndef STOCK_H_
#define STOCK_H_
#include <string>
class Stock{
private:
std::string company; //作用域 string
int shares;
double share_val;
double total_val;
void set_tot(){total=shares*share_val;}
public:
Stock(); //构造
Stock(const std::string &co,long n=0,double pr=0.0);
~Stock();
void buy(long num,double price);
void sell(long num,double price);
void update(double price);
void show()const; //无参数,又防止对象被改
const Stock &topval(const Stock & s)const; //传入一个显式对象和隐式对象作比较,反馈最值对象
};
#endif
//stock.cpp
#include <iostream>
#include "stock.h"
Stock::Stock() //初始化private属性
{
company="no name";
shares=0;
share_val=0.0;
total_val=0.0;
}
Stock::Stock(const std::string & co,long n,double pr)
{
company=co;
share_val=pr;
set_tot();
}
Stock::~Stock(){}
void Stock::buy(long num,double price){set_tot();}
void Stock::sell(long num,double price){set_tot();}
void Stock::update(double price){set_tot();}
void Stock::show()const{set_tot();}
const Stock & Stock::topval(const Stock &s)const
{
if(s.total_val>total.val)//隐式对象(*this)和显式(s)对比
return s;
else
return *this; //隐式对象没有名字咋办?用this指针!this是对象地址,return *this
13.类初始化3中方法
14.*和[ ]一点区别
char *a="abc"; //指针指向常量区,不可利用指针修改常量
char b[]="abc"; //可以更改abc内容
8.5.函数模板、实例化和具体化
创建泛型函数.适用于任何类型参数。
template <typename T> /<class T>
void swap(T &a,T &b){...}
实例化:隐式实例化和显式实例化??
具体化??
11.2 运算符重载??
将运算符用于类之间操作
格式:类名 operator+/*/-/.../(类名 &a){} //必须特殊名称operator
Box operator+(const Box& b) //重载加号
{
Box box;
box.length = this->length + b.length; //两个实例的length相加,隐式调用和显式调用
box.breadth = this->breadth + b.breadth;
box.height = this->height + b.height;
return box;
}
11.3友元
友元函数
- 引出:为了实现非成员函数直接访问类中私有成员(非成员函数:不属于任何类的函数)
- 步骤:
1.在类中声明:
含义:类中声明,但不是成员函数,不能使用成员运算符,但和成员函数访问权限一样。
2.在类外编写函数:
返回Time类,这样可以实现A=2.0*B的运算符重载和数字在前。
若用类内重载,A=B*2.0,左边必须是调用对象,2.0在后。使用友元函数,,.(补充吧,我现在也不知道它想干啥)
- 常用的友元<<
方法一:
方法二:
- 非成员函数和成员函数友元对比
12.7队列
- 构造函数成员初始化(const&引用)
const修饰的作为常量,只能初始化,不能赋值,因此const类成员要在构造前初始化(构造内是赋值)。
c++提供了一种特殊的初始化语法,初始化语句放置构造函数名后,大括号前,格式为:
Queue(int qs):front(NULL),rear(NULL),qsize(qs){} //queue为构造函数
不局限与常量,只用于构造函数,可以对初始化都这么操作
const类成员、引用类成员必须用这种方法初始化。
class Queue
{
private:
enum {Q_SIZE=10};
Node *front=NULL;
Node *rear=NULL;
const int qsize=Q_SIZE;
...
};
13.1 继承
基本的继承看之前c++文章。
多态继承
多态继承是为了基类方法可实现不同的功能......
格式:(+virtual)
- 动态联编:如果在派生类中重新定义基类方法,使用virtua多态+基类指针/引用,程序将根据对象类型而不是引用/指针确定哪个方法。(普通的基类指向派生类的指针只能调用基类对象)
静态联编:使用引用/指针确定的方法。
eg:
非多态:不管指向谁,都是Base
base->Show(); //base是基类指向派生类指针
结果:是基类指针,所以调用Base基类里的方法
多态:看指向base还是devrid
base->Show(); //base同上,不过用了多态
结果:base指向派生类,调用Devrid派生类的方法
- 多态时,基类声明里必须加virtual,派生类可加可不加;初始化基类派生类都不加virtual。
- 派生类析构函数有操作时,基类必须有个虚析构(~ 类名();)