C++学习笔记(2)——类与对象
回顾:
1.函数的缺省参数
1.1 声明的时候写,定义的时候不写
1.2 从右往左
1.3 核函数重载同用时需注意二义性问题
2.函数重载
2.1 在同一作用域内,函数名相同,参数列表不通
2.2 参数列表不同的方式
2.2.1 参数个数不同
2.2.2 参数顺序不同
2.2.3 参数类型不同
-
vs编译器的编程框架
stdafx.h的使用:
所有的.h头文件在其中引用项目中所有的.cpp问题必须包含stdafx.h
-
命令行参数
argc:命令行字符串的个数
argv:命令行的所有字符串(本质是一个二维数组)
argv[0] 字符串
argv[0][1] 字符 -
字符集
- 多字节字符集 strcmp strcpy strcat char
- 宽字节字符集 wchar_t
类与对象:
C++中 结构体中可以有成员函数
C++中 使用结构体的时候可以省略关键字
// 类和对象.cpp : 定义控制台应用程序的入口点。
#include "stdafx.h"
#include<string.h>
/*
编程语言描述的有且只有两种:
(C)事:流程 if else 循环 goto while for continue break
(C++)物:变量 数组 结构体
万物皆对象!!(先有类,再有对象)
类:概念 类型
对象:具体的实例
*/
struct student {//定义类型 类
//成员变量
char name[20];
int age;
double score;
//成员函数(C++) 功能 事 属性
//比如 show自己
void show() {
printf("名字:%s\n", name);
printf("年龄:%d\n", age);
printf("成绩:%g\n", score);
}
void Init(char* name, int age, double score) {
strcpy(this -> name,name);
this -> age = age;
this -> score = score;
}
};
//C语言中
void show(struct student* p) {
printf("名字:%s\n", p->name);
printf("年龄:%d\n", p->age);
printf("成绩:%g\n", p->score);
}
int main()
{
//结构 构造出 结构体 对象
struct student s1, s2, s3;
strcpy(s1.name, "zhangsan");
s1.age = 66;
s1.score = 90.05;
show(&s1);
s1.show();
s2.Init("lisi",19,70.50);
show(&s2);
s2.show();
while (1);
return 0;
}
名字空间:
为什么会有名字空间?
一个项目 很多人 一起开发
标识符 重用
fun1
名字空间的使用:
1.自定义名字空间
namespace name1{
语句;
}
2.使用名字空间
2.1 using namespace name1;
使用整个名字空间中的名字,而且使用了就全部暴露了
2.2 临时使用名字空间中的名字
名字空间名::标识符
例如:std::cout std::endl std::cin
2.3 使用名字空间中的某个名字(类似python调用库函数)
using 名字空间名::某名字
//名字空间第一种方法
#include "stdafx.h"
#include<string.h>
#include<iostream>
using namespace std;
namespace name1 {//名字空间的名字 name1
int n = 10;
void fun1() {
printf("名字空间1的fun1函数\n");
}
}
namespace name2 {
int n = 20;
void fun1() {
printf("名字空间2的fun1函数\n");
}
}
int main() {
using namespace name1;
printf("%d \n",n);
fun1();
printf("%d \n", name2::n);
name2::fun1();
cout << "我最帅\n";
while (1);
return 0;
}
C++的头文件:
iostream #include\<iostream> iostream.h
在C++代码中引用C语言自带的库
方式1:c风格 #include<string.h>
方式2:C++风格 #include<cstring>
//名字空间第二种方法
#include<string> //string类
#include<string.h> //等同于#include<cstring>,strcmp函数的头文件
#include<iostream>
int main() {
//using namespace std;
//C++风格的字符串
std::string str = "你好";
std::string str1;
str1 = str;
//C风格字符串
printf("str:%s\n", str.c_str());
printf("str:%s\n", str1.c_str());
printf("strsize:%d\n", str.size());
str1 += str;
printf("str:%s\n", str1.c_str());
while (1);
return 0;
}
//名字空间第三种方法
#include<string> //string类
#include<string.h> //等同于#include<cstring>,strcmp函数的头文件
#include<iostream>
using std::string;
int main() {
//C++风格的字符串
string str = "你好";
string str1;
str1 = str;
//C风格字符串
printf("str:%s\n", str.c_str());
printf("str:%s\n", str1.c_str());
printf("strsize:%d\n", str.size());
str1 += str;
printf("str:%s\n", str1.c_str());
while (1);
return 0;
}
C++的动态内存分配:
参考:【C++】动态内存分配详解(new/new[]和delete/delete[])_C/C++_Civil跨界工程师-CSDN博客 https://blog.csdn.net/qq_40416052/article/details/82493916
C语言基础之上能够做优化
malloc 和 free 函数
C++的动态内存分配
new 和 delete 运算符
new | malloc |
---|---|
new关键字是C++的一部分 | malloc是由C库提供的函数 |
new以具体类型为单位进行内存分配 | malloc以字节为单位进行内存分配 |
new在申请单个类型变量时可进行初始化 | malloc不具备内存初始化的特性 |
#include"stdafx.h"
#include<iostream>
using namespace std;
#include<stdlib.h>
int main(){
int n;
int* pc = (int*)malloc(sizeof(int));
int* p = new int;
int* pa = new int[6];
cin >> n; //scanf("%d",&n);
*p = n;
cout << "n:" << *p << end1;//printf("n:%d\n",*p);
while(1);
return 0;
}
内联函数,this指针:
this是个指针变量:
1.每个对象都有这个指针变量
2.这个指针变量指向对象本身
内联函数:
inline 关键字声明一个函数为内联函数
声明函数的同时定义函数(建议编译器将此函数设置为内联函数)
以膨胀内存的方式来节约时间
函数调用过程:
定义——声明——调用(需要跳转时间,参数出栈入栈)
两种解决方案:
1.宏函数 #define sum(x,y) ((x)+(y)) 只做简单代码替换
2.内联函数
两者区别:
1.时机
宏函数:预处理
内联函数:编译
2.编译器是否优化
宏函数:编译器不会优化,不做语法检查
内联函数:编译器会优化,做语法检查
3.传参
宏函数无传参过程,内联函数有传参过程
什么情况不建议设置为内联:
代码行数超过五行;
有循环递归等复杂流程;
调用次数少。
#pragma once //防止多次引用
struct Mystring {
//成员变量
char* buff;//字符串
size_t size;//字符个数
//成员函数
void init();
void strSet(char* str);
inline size_t getSize();//内联函数声明
void show();
};
// stdafx.h : 标准系统包含文件的包含文件,
// 或是经常使用但不常更改的
// 特定于项目的包含文件
//
#pragma once
#include "targetver.h"
#include <stdio.h>
#include <tchar.h>
// TODO: 在此处引用程序需要的其他头文件
#include"Mystring.h"
#include<string.h>
#include<stdlib.h>
//Mystring.cpp
#include "stdafx.h"
void Mystring::init() {
buff = NULL;
size = 0;
printf("初始化!\n");
}
void Mystring::strSet(char* str) {
//buff = str;
//1.获取字符串长度
size = strlen(str);
//2.开辟内存
if (buff)//如果原内存存在,释放
free(buff);
buff = (char*)malloc(size + 1);
memset(buff, 0, size + 1);//每个字节置为'\0'
//3.保存所有字符
//for (int i = 0; i < size; i++) buff[i] = str[i];
//syrcpy(buff,str); 等同 只针对字符串,一个一个
memcpy(buff,str,size); //速度更快 针对内存段,整块
}
size_t Mystring::getSize() {
return size;
}
void Mystring::show() {
printf("buff: %s\n",buff);
}
//main.cpp
#include "stdafx.h"//.cpp文件中都要引用
int main()
{
Mystring str1;
str1.init();
str1.strSet("hahahah");
printf("size: %d\n", str1.getSize());
str1.show();
while (1);
return 0;
}
C语言实现面向对象:
#include <stdio.h>
void init(struct student* s, int a, double d);
void show(struct student* s);
//void ()(struct student* , int , double ) //函数类型
struct student {
//成员变量
int age;
double score;
struct student* MyThis;
//成员函数(使用函数指针)
void(*pFuncInit)(struct student*, int, double);//指针变量名
void(*pFuncShow)(struct student*);
};
int main() {
struct student s1;
s1.MyThis = &s1;
s1.pFuncInit = init; //给函数指针变量赋值
s1.pFuncShow = show;
s1.pFuncInit(&s1, 33, 88.66);
s1.pFuncShow(&s1);
while (1);
return 0;
}
void init(struct student* s, int a, double d) {
//s->age = a;
s->MyThis->age = a;
//s->score = d;
s->MyThis->score = d;
}
void show(struct student* s) {
printf("age:%d score:%g\n",s->age,s->score);
}
运行结果: