基础知识
完全支持C语言
可以在C++引入C的头文件
#include <stdio.h>
#include <iostream>
int main() {
}
输入和输出
C++中的输入使用cin，输出使用cout
#include <stdio.h>
#include <iostream>
int main() {
int i;
//C++中的输入和输出
std::cin >> i;
std::cout << i << std::endl;
//C中的输入和输出
scanf("%d", &i);
printf("%d
", i);
}
名字空间
为了在大型项目开发中解决类，函数命名冲突问题而引入了namespace。下面的代码中引入了C++中的标准库命名空间std,这样我们就不用在cin，cout,endl前面添加命名空间了
#include <iostream>
using namespace std;
namespace outer {
void outerTest() {
cout << "this is outer namespace" << endl;
}
}
int main() {
outer::outerTest();
}
结构体和类
结构体成员默认对外开放,随时随地都可以访问。class中的成员默认私有,无法直接访问。这里的struct和class一样，内部可以使用权限修饰符，函数等。
#include <iostream>
struct man {
int age;
int sex;
};
class man2 {
int age;
int sex;
};
int main() {
man m;
m.age = 10; // 可以正常赋值
m.sex = 0; // 可以正常赋值
man2 man2;
man2.age = 11; // 编译报错
man2.sex = 1; // 编译报错
}
对象的分配
通过new创建对象，通过delete释放对象，注意数组的释放有点特殊；
int main() {
int* p1 = new int();
int* p2 = new int[10];
delete p1;
delete []p2;
}
引用
引用不是地址，只是变量的别名，引用不占用空间，引用只能被初始化一次且在声明时初始化。
#include <iostream>
#include <stdio.h>
using namespace std;
void mSwap (int &a, int &b) {
int tmp;
tmp = a;
a = b;
b = tmp;
}
int main() {
int a = 10;
int b = 5;
mSwap(a, b); //交换成功
cout << a << b << endl;
//引用在声明时必须被初始化且不能更改
int& c = a;
//输出的值一致,所以引用不占空间
printf("c地址为:%p, a地址为:%p
", &c, &b);
}
在值传递的情况下，void mSwap (int a, int b)它会将传入的参数拷贝一份，然后在自己的栈帧内对拷贝的数据进行操作。而使用引用传递void mSwap (int& a, int& b)则会直接操作main函数栈帧上的变量，所以后者能交换成功，这就是跨栈操作。如果希望传递引用又不想被修改可以使用下面方式
void mSwap (const int &a) {
cout << a << endl;
}
缺省参数
#include <iostream>
using namespace std;
void m (int a = 10) {
cout << a << endl;
}
int main() {
m(); // 输出10
m(11); // 输出11
}
模版
模版在对不同数据做相同操作时用到，其核心就是泛型。下面就是一个模版函数的使用，可以支持整型和浮点的加操作
#include <iostream>
using namespace std;
template <class T>
T myadd(T a, T b) {
return a + b;
}
int main() {
cout << myadd(1, 2) << endl;
cout << myadd(1.0, 3.0) << endl;
}
指针常量与常量指针
指针常量：指针是个常量，不能修改指针的值；常量指针：指针指向的位置是个常量(在指针看来)，不能通过指针修改其值
int main() {
int a=0;
int b = 1;
// 指针常量,p的值不能被修改
int* const p = &a;
p = &b; //编译错误,不能修改p的值
*p = 10;
// 常量指针,p1的值可以被修改
const int* p1 = &a;
p1 = &b;
*p1 = 10; //编译错误,不能通过指针p1修改其指向的值
a = 11;
b = 12;
}
类的初始化
man.h文件中声明一个类
#ifndef MAN_H
#define MAN_H
#include <string>
using namespace std;
class Man {
public:
Man();
~Man();
protected:
private:
int& a;
int b;
string name;
const int age;
};
#endif // MAN_H
man.cpp中初始化成员
#include "man.h"
Man::Man():age(10),a(b) { // 注意常量,引用必须在成员列表初始化
name = "tom";
}
Man::~Man() {
//dtor
}
拷贝
拷贝一般应实现拷贝函数，如果未实现则采用默认拷贝函数
class Test {
public:
Test(const Test& t); //自定义拷贝函数
}
Test t1;
Test t2 = t1; //调用拷贝函数
静态变量与静态成员
在C中一个变量被static修饰后，这个变量将处于静态数据区。比如下面的代码，程序被加载到内存后，只有当test1被调用后变量a才会被创建(在栈上创建)。但是对于test2而言，程序一旦被加载,即使没有调用test2,变量a都存在了。
void test1(){
int a = 0;
}
void test2() {
static int a = 0;
}
C++中的静态成员属于类成员，只要类被加载了，该成员就就会在内存中被创建出来。
静态成员只能在类外部被初始化。
Man.h文件中声明类
class Man
{
public:
Man();
~Man();
static int a;
};
Man.cpp
#include "Man.h"
int Man::a = 100; //对静态成员初始化
Man::Man()
{
}
Man::~Man()
{
}
数组的初始化
定义一个对象数组
int main(int argc, char **argv) {
//调用无参构造函数
Man man[3];
//调用有参构造函数
Man man2[3] = {Man(1), Man(2), Man(3)};
}
实践
MyString.h
#ifndef MYSTRING_H
#define MYSTRING_H
namespace xdysite {
class MyString {
public:
MyString(const char* str);
~MyString();
MyString(const MyString& myString);
const char* getString();
void setString(const char* str);
private:
char* str;
};
}
#endif // MYSTRING_H
MyString.cpp
#include "MyString.h"
#include <algorithm>
#include <cstring>
using namespace std;
xdysite::MyString::MyString(const char* str) {
int len = strlen(str);
this->str = new char[len + 1];
strncpy(this->str, str, len);
}
xdysite::MyString::~MyString() {
delete []str;
str = NULL;
}
xdysite::MyString::MyString(const MyString& myString) {
int len = strlen(myString.str);
str = new char[len + 1];
strncpy(str, myString.str, len);
}
const char* xdysite::MyString::getString() {
return str;
}
void xdysite::MyString::setString(const char* str) {
int len1 = strlen(str);
int len2 = strlen(this->str);
if(len2 >= len1)
strncpy(this->str, str, len1);
else {
delete []this->str;
this->str = new char[len1 + 1];
strncpy(this->str, str, len1);
}
}
man.cpp
#include <iostream>
#include "MyString.h"
using namespace std;
using namespace xdysite;
int main(int argc, char **argv) {
MyString myString = "hello world!";
MyString myString2 = myString;
myString.setString("HELLO");
cout << myString2.getString() << endl;
}