c++知识点散记

最新推荐文章于 2022-11-08 23:23:54 发布

Gogool

最新推荐文章于 2022-11-08 23:23:54 发布

阅读量490

点赞数

本文链接：https://blog.csdn.net/Gogool/article/details/105203660

版权

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。
派生类析构函数有操作时，基类必须有个虚析构(~ 类名();)

Gogool

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
c++知识点散记

1.结构体&共用体结构体能存储int，double和long；共用体能存储int，double或longunion perval{double double_val;int int_val;};perval per; //初始化union，c++中可不加union类型 c：union perval per；per.int_val=15;cout<<pe...
复制链接

扫一扫