一文搞懂C++（上）

最新推荐文章于 2025-03-14 16:03:02 发布

socket()

最新推荐文章于 2025-03-14 16:03:02 发布

阅读量639

点赞数 7

文章标签： c++ 开发语言

本文链接：https://blog.youkuaiyun.com/m0_57508000/article/details/144198302

版权

一、C语言和C++

1、bool类型（c语言中没有，c++中有）

1）两个取值：用来描述真、假，true/false

2）占1字节

3)非0为真

2、内联函数

1）用空间换时间，可以提高程序速率

2）内存膨胀，原来只有声明在代码区，其他在栈区，内联函数定义在代码区，节约了调用函数的时间

3）适合代码简单，多次调用的情况

4）函数格式

inline int fun(int num){

函数体

}

3、函数重载

1）在一个项目中，定义两个名字相同的函数，但参数列表必须不同，个数/类型均可

2）下面情况不构成函数重载

int func(){};

float func(){};

类型不同，但参数相同

3）举例

float func(){

}

double func(int num){

}

int main(){

func();

func(x);

}

4、函数参数缺省

1）在实际应用中，调用函数写实参，因此实参多于形参的使用

2）含义：声明函数的某个参数时，指定一个默认值

void func(int num = 0,double val = 3,14){
}
int main(){
func(1,4.5);
func(3);//缺省处理
}

3）缺省只能从后往前缺

4）如果是函数声明，默认值在函数声明的时候给，定义函数的时候不需要给，不能反过来。

5）不能函数重载

5、引用

1）定义：给对象或函数取别名

2）定义引用时必须初始化，一旦引用，不能更改或重复，需要说清是谁的别名

int num;
int& dd = num;

3）引用只是别名，用的是同一块内存

int num = 0;
int& dd = num;
printf("num = %d",dd);
dd = 10;
printf("num = %d",dd);

0;10

4）引用可以是指针、结构体

6、命名空间

1）定义：用来组织和重用代码的编译单元

通过命名空间来避免冲突，解决重名问题

2）作用域运算符：：读作“里面的”

namespace NAME_1
{
int num = 10;
void func1(){
printf("hello world\n");
}
void func1();
}
//命名空间不加引号
void NAME_1::func1(){
printf("helloworld\n");
}
int main(){
int num = 9;
printf("num = %d\n",num);
printf("num = %d\n",NAME_1::num);
}


9;10

3）命名空间可以嵌套定义，但不能在函数里面

4）可以分不同地方定义同一个命名空间（重名）

5）命名空间取别名（当命名空间过长）

namespace N = NAME_1;

7、cin和cout

以下三段代码等同

#include<iostream>
std::cin>>num;
std::cout<<num;
std::cout<<num<<endl;

#include<iostream>
using namespace std;
cin>>num;
cout<<num<<endl;

//using namespace
using std::cin;
using std::cout;

7、new和delete

1）类似于malloc和free

#include<iostream>
using namespace std;
int main(){
//申请单个内存
int *p1 = new int;
*p1= 0;
cout<<"*p1 = "<<*p1<<end;
//申请单个内存并初始化
int *p2 = new int(999);
cout<<"*p2 = "<<*p2<<end;
//连续申请多个内存
int *p3 = new int[10];
for(int i = 0;i<10;i++){
p[i] = i;
cout << "p3 = "<<i<<p3[i]<<endl;
}
delete p1;
delete p2;
delete[] p3;
}

2)单个初始化用（），多个初始化用[]

3)delete p3[]：p3首地址的地方到后面做标记的地方（连续一段内存），p3必须为首地址开始的地方。

二、面向过程和面向对象

（一）面向过程

提出问题-分析问题-处理问题

大问题-中问题-小问题

做好这一步，做下一步，直到做完

1、洗澡问题

调用函数->洗澡前(找衣服函数、开热水器函数)-洗澡中-洗澡后

2、优点

1）把问题简化，有条理划分问题

2）使程序结构简单，语法简单，主要是顺序、选择、循环

3）对整个问题有清晰的全貌，知道正确完整的过程

3、缺点

1）数据和函数是分开的，程序散乱，如函数定义的参数类型都是int的，如果参数类型被修改，代码的修改两较大

2）数据公开透明，数据不具有封装性，容易被篡改，不安全，不能上密码

3）函数重载，不适合多人开发

（二）面向对象

1、概述

1）面向过程的继承和发展，是比过程更加完善的思想，可以理解为现实世界是由对象组成的

2）对象在程序中抽象成两部分：属性和行为

属性对应数据，行为对应函数

3）想要实现洗澡的功能->去创造能够实现洗澡功能的对象

4）有问题，创造一个能解决问题的对象

2、特点

1）数据和行为总是结合在一起的，用来表达一个东西就是创造对象，数据和行为分开会导致维护不便，面向对象可以解决这个问题

2）问题分解成一个一个对象能解决的问题

3、面向对象的四个特性：继承、封装、多态、抽象（c++中的类和对下那个，把所有问题的对象提取出相同的属性或行为叫抽象）

3、优点

维护方便，代码重复率比较一样，多线程，低耦合，组件编程

三、类和对象

1、类中可以有数据也可以有函数，函数和数据紧密结合，可以隐藏数据，属性对应数据，函数对应行为

2、类的定义：类是具有相同属性或行为的集合

3、类是对象的抽象，对象是类的具体

4、对象：通过使用类类型定义的变量

5、定义类

class 类名
{
//默认是私有的
private:
//成员  数据  函数
protected:
public:
}

class sheep{
int age;
public:
char name[32];
void eat(){
cout<<"吃点草"<<endl;
}
void speak(){
cout<<age<<endl;//在类中可以使用私有数据
}
private:
void speakEnglish(){
cout<<name<<endl;
}
};
void sheep::speak()//声明在内，定义在外
{
cout<<...
}

//定义对象
int main(){
sheep xiYY;
strcpy(xiYY.name,""喜羊羊);
xiYY.speak();
}

//可以通过一个公有函数修改私有成员
class sheep{
private:
int age = 10;
public:
void set_age(int n){
age = n;
}
};
int main(){
class sheep;
sheep.age_set(10);
}

//使用指针
sheep *p1;
p1 = &xiYY;
p1->eat();
p1->speak();

6、class和struct关键字

在c++中，struct可以定义一个类或结构体，默认公有，但一般使用class，默认公有。

四、string类

#include<string>(没有.h，在c++中不存在.h文件)
string str;
str = "123456";
str.length();//求长度
str.clear();
str == str；//比较
char ch = str[2];

class sheep{
public:
string name;
}

int main(){
sheep xiYY;
xiYY.name = "喜羊羊"；
}

五、构造函数和析构函数

（一）普通构造函数

1、定义：创建对象时，完成数据成员的初始化

2、是一种特殊的成员函数

3、构造函数和函数类名相同，参数可以修改

4、构造函数没有返回值类型，也没有返回值

5、构造函数可以函数重载，需要满足函数重载的条件

class myclass{
public:
int num;
private:
int val;
public:
myclass();
myclass(int n,int v){
num = n;
val = v;
}
};
//类外定义，没有返回值类型
myclass::myclass(){

}

6、总结

1）如果定义类时，没有定义构造函数，系统会自动创建构造函数

2）如果在类中定义构造函数，等同于内联函数，所有一般都在类内声明，在类外面，进行定义

3）构造函数会在定义一个类时去调用（系统自动），不能通过对象去调用构造函数，自己不用调，系统主动调。

myclass::myclass(int n,int v){
num = n;
val = v;
}
int main(){
myclass p1;
myclass p1(1,2);
}

4）构造函数只能在public下定义，系统给的也是

5）多个构造函数（函数重载），系统就不会默认分配了

6）如果构造函数有参数，在定义对象时需要传参（可以缺省）

7）在c++中，const修饰的变量变成常量，但在c语言中，还是变量，相当于只读

8）有的数据必须初始化，如const int

6、使用成员初始化列表

class myclass(){

public:

const int id;

const int num;

const int val;

public:

myclass(int i,int n):id(i),num(n){

}

};

类外定义

myclass ::myclass(int i),id(i){

}

六、析构函数

1、是一种特殊的函数

2、主要是在对象生命周期结束后进行清理

3、系统可以自动调用析构函数，也可以自己调用

4、析构函数和类型相同，前面加~

5、没有返回值和返回值类型，也没有参数

6、系统默认分配，默认共有

class obj;
obj.~class();

7、对象生命周期结束时才会调用，不是导致程序结束的原因

8、任何想在对象结束时执行的程序，都可以写在析构函数

七、拷贝构造函数

1、是一种特殊的构造函数

2、通过它完成复制的过程，从一个对象得到另一个相同的对象。

3、第一个参数必须是本类的对象的引用

4、先是构造函数，才有可能是拷贝构造函数

5、系统默认给，将成员一一对应赋值，也可以自定义

class myclass{
public:
myclass();
~myclass();
myclass(const myclass& obj){}
};


myclass(const myclass& obj){}
myclass(const myclass& obj,int n){}
//错误用法
myclass(int m,const myclass& obj,int n){}

myclass::myclass(myclass &obj){
name = obj.name;
hp = obj.hp;
speed = obj.speed;
}
myclass::myclass(myclass &obj,int hp1){
name = obj.name;
hp = hp1;
speed = obj.speed;
}

myclass m0; //构造
myclass m1("皮卡丘"，“120.12”);//构造
myclass m2 = m3; //拷贝
myclass m4(m0); //拷贝
myclass m5(m0,12);//拷贝
myclass *p = new myclass;

6、调用时机：

1）对象作为形参

2）返回值是类的对象