fun()
函数,但是 ()
中的传值要不一样,数量要不一样,这样才能进行重复的命名,看下面1.7的函数重载using namespace std;
命名空间:
防止工程过大
所导致的全局变量命名重复
所有的变量甚至是函数都可以写到这个命名空间内部!
可以防止重复命名
命名空间的定义:
命名空间有空间名!
#include
using namespace std;
// main() 是程序开始执行的地方
int main()
{
cout << "Hello World"; // 输出 Hello World
return 0;
}
C语言输入输出
三大标准文件:
stdin stdout stderr
一些函数比如下面的两个都是在这里面的
printf();
scanf();
C++
首先可以用C语言的输入输出!
他还可以用
cout
cin输入
注意:
cout 与 cin属于 std空间
所以使用的时候必须声明命名空间才可以使用
传参,什么情况下传的是 值 ,什么情况下传参,四个函数的使用方法
C++的引用
原则上是给变量起一个别名!
实际上是为了方便传参
举个例子:
int a = 10;
int &b =a;
变量a 他的别名 就是 b
a 和 b 指向的是同一个空间
更多的这种情况是为了传参方便
而不是用指针传参
#include
void fun(int num)
{
//像这样的传参--传的不是变量本身而是变量的值!
num++;
}
//我现在就像通过一个函数让 num++该怎么办!
int fun1(int num)
{
num++;
return num;
}
//C语言指针
void fun2(int * num)
{
(* num) ++;
}
//引用
void fun3(int &num)
{
num++;
}
int main()
{
int num = 10;
fun(num); //像这里就是只传递了值,而没有传递参数
printf("num==%d\r\n",num);
//有人认为是 10 ->正确答案
num = fun1(num);
printf("num==%d\r\n",num);//11
fun2(&num);
printf("num==%d\r\n",num);//12
fun3(num);
printf("num==%d\r\n",num);//13
return 0;
}
C语言中有正确错误的概念
正确在C语言中就是 非0->1
错误在C语言中就是 0
C++为了更加方便区分正确和错误
专门搞出来bool
这个bool类型一共有两个值
true false
1 0
例如:
string str1;
string str2;
str1 = "hello"
str2 = "hello"
str1 == str2
strcmp //C语言中要用到的函数
str3 = str1+str2;
strcat //C语言中要用到的函数
有些函数会有默认的参数传进去,防止出现一些错误
在C++函数允许有默认传参
大部分的功能、库、外设
都会提供一定的功能;
这些函数需要你传入不同的参数完成不同的功能
open_led(int port);
由于我根本不了解 port-->引脚
open_led(10000);
可能这个函数不但不能点亮LED灯
甚至会造成系统错误。。。
由于可能会出现这样的问题
C++推出这种默认传参的机制
当我不知道该怎么传参的时候
直接调用函数即可
有些函数会有默认的参数
void fun(string str="hello world")
{
cout<<str;
}
很多情况下
函数的功能
Qt、OpenCv函数都会拥有默认传参
默认传参的功能一般都是防止不传参导致的问题
允许函数名字重复,前提是参数不能重复,如下面的示例
C++函数的重载
正常在C语言中
机会是不能看到一个函数名字重复的函数
但是这种情况在C++中很常见很常见!
在C++中允许函数名字重复
但是前提是名字可以重复你的参数是不能重复的!
这样的函数我们叫做函数的重载!
// 多整几个重复命名的函数,但是传递的参类型和数量不一样
void fun(void)
{
cout << "i am fun1"<<endl;
}
int fun(int num,int num2)
{
cout << "i am fun2"<<endl;
}
int fun(int num,int num2,int num3)
{
cout << "i am fun3"<<endl;
}
void fun(int num)
{
// 像这样的传参--传的不是变量本身而是变量的值!
num++;
cout << "i am fun4"<<endl;
}
https://code.visualstudio.com/
链接:https://pan.baidu.com/s/1tdoHH76BpJins-AGiP4dbw
提取码:7j9t
找到文件位置,在文件的所在位置打开终端,输入
sudo dpkg -i code_1.65.1-1646706496_amd64.deb
1)、 C/C++,这个肯定是必须的。
2)、 C/C++ Snippets,即 C/C++重用代码块。
3)、 C/C++ Advanced Lint,即 C/C++静态检测 。
4)、 Code Runner,即代码运行。
5)、 Include AutoComplete,即自动头文件包含。
6)、 Rainbow Brackets,彩虹花括号,有助于阅读代码。
8)、 GBKtoUTF8,将 GBK 转换为 UTF8。
9)、 ARM,即支持 ARM 汇编语法高亮显示。
10)、 Chinese(Simplified),即中文环境。
11)、 vscode-icons, VSCode 图标插件,主要是资源管理器下各个文件夹的图标。
12)、 compareit,比较插件,可以用于比较两个文件的差异。
13)、 DeviceTree,设备树语法插件。
gdb教程:
http://c.biancheng.net/gdb/
类似于C的结构体
class
类的定义:
class student
{
int age;
string name;
string birth;
};
class student tmp; //实例化类
tmp.age;
tmp.name;
tmp.birth
C++ 类访问修饰符——菜鸟教程
类内部的所有成员都会有自己的属性,属性决定了成员的权限
类的成员有三个属性 -> public
private
protected
public:
#include
#include
using namespace std;
class A{
public:
int a;
A(){
a1 = 1;
a2 = 2;
a3 = 3;
a = 4;
}
void fun(){
cout << a << endl; //正确
cout << a1 << endl; //正确
cout << a2 << endl; //正确
cout << a3 << endl; //正确
}
public:
int a1;
protected:
int a2;
private:
int a3;
};
class B : public A{
public:
int a;
B(int i){
A();
a = i;
}
void fun(){
cout << a << endl; //正确,public成员
cout << a1 << endl; //正确,基类的public成员,在派生类中仍是public成员。
cout << a2 << endl; //正确,基类的protected成员,在派生类中仍是protected可以被派生类访问。
cout << a3 << endl; //错误,基类的private成员不能被派生类访问。
}
};
int main(){
B b(10);
cout << b.a << endl;
cout << b.a1 << endl; //正确
cout << b.a2 << endl; //错误,类外不能访问protected成员
cout << b.a3 << endl; //错误,类外不能访问private成员
system("pause");
return 0;
}
private:
#include
#include
using namespace std;
class A{
public:
int a;
A(){
a1 = 1;
a2 = 2;
a3 = 3;
a = 4;
}
void fun(){
cout << a << endl; //正确
cout << a1 << endl; //正确
cout << a2 << endl; //正确
cout << a3 << endl; //正确
}
public:
int a1;
protected:
int a2;
private:
int a3;
};
class B : private A{
public:
int a;
B(int i){
A();
a = i;
}
void fun(){
cout << a << endl; //正确,public成员。
cout << a1 << endl; //正确,基类public成员,在派生类中变成了private,可以被派生类访问。
cout << a2 << endl; //正确,基类的protected成员,在派生类中变成了private,可以被派生类访问。
cout << a3 << endl; //错误,基类的private成员不能被派生类访问。
}
};
int main(){
B b(10);
cout << b.a << endl; //正确。public成员
cout << b.a1 << endl; //错误,private成员不能在类外访问。
cout << b.a2 << endl; //错误, private成员不能在类外访问。
cout << b.a3 << endl; //错误,private成员不能在类外访问。
system("pause");
return 0;
}
protected:
#include
#include
using namespace std;
class A{
public:
int a;
A(){
a1 = 1;
a2 = 2;
a3 = 3;
a = 4;
}
void fun(){
cout << a << endl; //正确
cout << a1 << endl; //正确
cout << a2 << endl; //正确
cout << a3 << endl; //正确
}
public:
int a1;
protected:
int a2;
private:
int a3;
};
class B : protected A{
public:
int a;
B(int i){
A();
a = i;
}
void fun(){
cout << a << endl; //正确,public成员。
cout << a1 << endl; //正确,基类的public成员,在派生类中变成了protected,可以被派生类访问。
cout << a2 << endl; //正确,基类的protected成员,在派生类中还是protected,可以被派生类访问。
cout << a3 << endl; //错误,基类的private成员不能被派生类访问。
}
};
int main(){
B b(10);
cout << b.a << endl; //正确。public成员
cout << b.a1 << endl; //错误,protected成员不能在类外访问。
cout << b.a2 << endl; //错误,protected成员不能在类外访问。
cout << b.a3 << endl; //错误,private成员不能在类外访问。
system("pause");
return 0;
}
类内实现:比较常见
类外实现:在类内声明,在类外实现(函数体在类外),Qt比较常用,比如Qt的槽函数
class student
{
//公共的
public:
int a;
void fun(void)//类内实现
{
b = b+1;//类内访问
c = c+1;//类内访问
}
void test(void);//函数声明 这个函数是属于student类的!
//私有的
private:
int b;
//受保护的
protected:
int c;
};
void student::test(void)//类外实现、类内声明的函数
{
cout<<"hello i am student test!\r\n";
}
构造函数(和类名相同):实例化(创建对象)的时候必然要调用的初始化函数,对象创建时自动调用
析构函数(~ 加上类名):对象摧毁的时候回调的释放的函数,对象被摧毁的时候自动调用(return的时候)
class Student
{
private:
/* data */
public:
Student(/* args */);
~Student();
};
Student::Student(/* args */)
{
}
Student::~Student()
{
}
直接继承父类的内容
格式
继承的权限
采用公共继承的情况下:
class student
{
public:
int a;
private:
int b; //绝对不会继承b
//受保护的
protected:
int c;
};
//newstudent 公共的方法集成了student的属性!
class newstudent:public student
{
public:
int d;
void fun(void)
{
c =20;
}
};
公共的继承
class newstudent:public student
相当于
class newstudent
{
public:
int d;
int a;
void fun(void)
{
c =20;
}
protected:
int c;
}
受保护继承
class newstudent:protected student
class newstudent
{
public:
int d;
void fun(void)
{
c =20;
}
protected:
int a;//继承的权限不同!
int c;
}
私有继承
class newstudent:private student
相当于:
class newstudent
{
public:
int d;
void fun(void)
{
c =20;
}
private:
int a;//继承的权限不同!
int c;
}