C++ 栈 字符串

最新推荐文章于 2023-06-21 19:14:42 发布
最新推荐文章于 2023-06-21 19:14:42 发布
阅读量1.1k 收藏
点赞数 1
文章标签： 大数据
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_62538383/article/details/125629213
版权

1.拷贝构造函数

 

1.1拷贝构造函数是构造函数的一种重载形式

1.2不能使用常数 只能使用引用并加const（consy Complex &cdd）

2.构造函数中字符串的拷贝用strcpy_s(&目的字符串,长度，&源字符串)

3.三种引用方案

值传递

引用传递

常引用传递

4.局部对象只能以值的类型返回&&返回类型不允许是引用类型

#除非生存期不受函数影响

5.实现栈的深拷贝

	//Mystack深拷贝函数
	Mystack(const Mystack& s) {
		_size = s._size;
		_top = s._top;
		data = new int[_size];
		memmove(data, s.data, sizeof(int) * (_top + 1));
	}
#include <stddef.h>
#include<string.h>
#include<iostream>
#include<string>
using namespace std;
class Mystack {
	enum { total_size = 10, nsize = 2 };
private:
	int* data;
	int _size;
	int _top;
	//增容
	bool Capacity(int newSize) {
		int* newdata = new int[newSize];
		memmove(newdata, data, _size * sizeof(int));
		delete[]data;//不可省略
		data = newdata;
		_size = newSize;
		return true;
	}

public:
	Mystack() :data(nullptr), _size(total_size), _top(-1) {
		data = new int[total_size];
	}
	Mystack(int t) :data(nullptr), _size(t), _top(-1) {
		data = new int[total_size];
	}
	~Mystack() {
		delete[]data;
		data = nullptr;
		_size = 0;
		_top = -1;
	}
	//Mystack深拷贝函数
	Mystack(const Mystack& s) {
		_size = s._size;
		_top = s._top;
		data = new int[_size];
		memmove(data, s.data, sizeof(int) * (_top + 1));
	}
	//判满  判空  入栈  出栈  获取栈元素  获取栈顶元素  
	bool Full() {
		return (_top + 1) >= _size;
	}
	bool Empty() {
		return (_top == -1);
	}
	bool Push(int val) {
		if (Full() && !Capacity(nsize * _size))  return false;
		_top += 1;
		this->data[_top] = val;
		cout << val << "已入栈" << endl;
		return true;
	}
	bool Pop() {
		if (Empty()) return false;
		_top -= 1;
		return true;
	}
	bool  Get_Topvel(int& a) {
		if (Empty()) return false;
		a = this->data[_top];
		return true;
	}
	bool Pop_val(int& a) {
		if (Empty()) return false;
		a = this->data[_top];
		cout << a << "已出栈" << endl;
		_top -= 1;
	}
};
int main() {
	Mystack s;
	int c;
	for (int i = 0; i < 10; i++) {
		s.Push(i);
	}
	Mystack s1(s);
	cout << "s1" << endl;
	while (!s1.Empty()) {
		
		s1.Pop_val(c);
	}

}

6.实现字符串的深拷贝

#include <stddef.h>
#include<string.h>
#include<iostream>
#include<string>
using namespace std;
//字符串类
class Mystring {
private:
	char* str;
public://有参 析构 拷贝
	Mystring(const char *p=nullptr):str(nullptr) {
		if (p != nullptr) {
			int len = strlen(p) + 1;
			str = new char[len];
			strcpy_s(str, len, p);
		}
	}
	~Mystring() {
		if (str != nullptr) {
			delete[]str;
		}
		str = nullptr;
	}
	Mystring(const Mystring &s) {
		int n = strlen(s.str) + 1;
		this->str = new char[n + 1];
		strcpy_s(str, n , s.str );
	}
	/*Mystring(const Mystring& s) {
		str = s.str;
	}*/
	//error

	//打印
	void Print_Str() {
		cout << str << endl;
	}

};
int main() {
	Mystring ys("buling!");
	Mystring ds(ys);
	ys.Print_Str();
	ds.Print_Str();
	return 0;
}

7.在使用字符串时，赋值或者拷贝函数应该先计算长度  然后new开辟空间

8.strcpy_s针对字符串赋值  mencpy针对整形赋值

9.在赋值函数中应该判断this指针的地址与&s的指针地址是否相等  以防自己给自己赋值

10.栈的赋值重载

	Mystack&  operator=(const Mystack& c) {
		if (this != &c) {
			delete[] data;
			data = new int[_size];
			memmove(data, c.data, sizeof(int) * (_top + 1));
			_size = c._size;
			_top = c._top;
		}
	}

11.构造函数三特性  1.创建对象  2.创建对象  3.类型转换

12.后置++（int ）

13.x+Int a

Int operator+(int x, const Int& a) {
	return a + x;
}
#include <stddef.h>
#include<string.h>
#include<iostream>
#include<string>
using namespace std;
//整形类
class Int {
private:
	int value;
public:
	Int() :value(0) {
		cout << "无参" << endl;
	}
	Int(int x) :value(x) {
		cout << "有参" << endl;
	}
	~Int() {
		cout << "析构" << endl;
	}
	Int(const Int& c) {
		value = c.value;
	}
	//c = a + b;     c=a+x   c=x+a   a.operator(x)
	Int operator+(const Int& c) const{//运算符重载 
		int t = value + c.value;
		return Int(t);
	}
	//a=a+b;
	Int operator+=(const Int& c) {
		value = value + c.value;
		return *this;
	}
	//c=++a   c=a   a=a+1
	//前置++
	Int operator++() {
		value += 1;
		return *this;
	}
	//后置++
	Int operator++(int) {
		Int c;
		c.value = value;
		value += 1;
		return c;
	}
	void Print() {
		cout << "value=  " << value << endl;
	}
};
//Int c=x+a;
Int operator+(int x, const Int& a) {
	return a + x;
}
int main() {
	Int a{ 10 }, b{ 20 }, c{ 0 };
	int x = 50;
	c = a + b;
	c.Print();
	c = a + x;
	c.Print();
	c = x + a;
	c.Print();
}

14.大杂烩

#include <stddef.h>
#include<string.h>
#include<iostream>
#include<string>
using namespace std;
//整形类
class Int {
private:
	int value;
public:
	Int() :value(0) {
		cout << "无参" << endl;
	}
	Int(int x) :value(x) {
		cout << "有参" << endl;
	}
	~Int() {
		cout << "析构" << endl;
	}
	Int(const Int& c) {
		value = c.value;
	}
	//c = a + b;     c=a+x   c=x+a   a.operator(x)
	Int operator+(const Int& c) const {//运算符重载 
		int t = value + c.value;
		return Int(t);
	}
	//c=a+x
	Int &operator+(const int value )  {//运算符重载 
		this->value+=value;
		return *this;
	}
	//a=a+b;
	Int operator+=(const Int& c) {
		value = value + c.value;
		return *this;
	}
	//c=++a   c=a   a=a+1
	//前置++
	Int operator++() {
		value += 1;
		return *this;
	}
	//后置++
	/*Int operator++(int) {
		Int c;
		c.value = value;
		value += 1;
		return c;
	}*/
	Int operator++(int) {
		return Int (this->value ++);
	}
	void Print() {
		cout << "value=  " << value << endl;
	}
	int Value()const {
		return  value ;
	}
	//强转Int a ->int a
	operator int() {
		return this->value;
	}
//	c  a
	//bool operator<(const Int& a) {
	//	return this->value < a.value;
	//}
	c  x
	//bool operator<(const int x) {
	//	return this->value <x;
	//}
};
//Int c=x+a;
Int operator+(int x, const Int& a) {
	return a + x;
}
//x+=a;    (x,&a)
int & operator+=(int &value, const Int & a) {
	  value=value+ a.Value();
	  return value;
}
//x  c
//bool operator<(int& x, const Int& c) {
//	return x < c.Value();
//}
//x  y
int main() {
	Int a{ 70 }, b{ 50 }, c{ 0 };
	int x = 50,y=10;
	int w = a;
	cout << w << endl;
}
//#include <stddef.h>
//#include<string.h>
//#include<iostream>
//#include<string>
//using namespace std;
//class Mystring {
//private:
//	char* str;
//public:
//	Mystring(const char* p = nullptr) :str(nullptr) {
//		if (p != nullptr) {
//			size_t n = strlen(p) + 1;
//			str = new char[n];
//			strcpy_s(str, n, p);
//		}
//	}
//	~Mystring() {
//		if (str != nullptr) {
//			delete[]str;
//		}
//		str = nullptr;
//	}
//	//(&c,a)
//	Mystring(const Mystring& c) {
//		size_t n = strlen(c.str) + 1;
//		this->str = new char[n];
//		strcpy_s(str, n, c.str);
//	}
//	void Print_str() {
//		cout << "str:" << str << endl;
//	}
//	//赋值重载函数c=a
//	Mystring&  operator=(const Mystring& s) {
//		if (this != &s) {
//			size_t n = strlen(str) + 1;
//			delete[] str;
//			str = new char[n];
//			strcpy_s(str, n, s.str);
//			return *this;
//		}
//	}
//	//s3=s1+s21   
//	Mystring  operator+(const Mystring& s) const  {
//		size_t n1 = strlen(str)+1;
//		size_t n2 = strlen(s.str)+1;
//		char* p = new char[n1 + n2 +3]; int i = 0, j = 0;
//		for ( i = 0; str[i] != '\0'; i++) {
//			p[i] = str[i];
//		}
//		for ( j = 0; s.str[j] != '\0'; j++) {
//			p[i] = s.str[j];
//			i++;
//		}
//		p[i] = '\0';
//		return Mystring(p);
//	}
//	//c=a+=b     a=a+b
//	Mystring& operator+=(const Mystring& s) {
//		size_t  n1= strlen(str) + 1;
//		size_t n2 = strlen(s.str) + 1;
//		char* p = new char[n1 + n2+3];
//		int i = 0, j = 0;
//		for (i = 0; str[i] != '\0'; i++) {
//			p[i] = str[i];
//		}
//		for (j = 0; s.str[j] != '\0'; j++) {
//			p[i] = s.str[j];
//			i++;
//		}
//		p[i] = '\0';
//		delete[] str;
//		strcpy_s(str, n1 + n2 , p);
//		str = p;
//		return *this;
//	}
//	//char ch = s3[1];       (s3,1)                                         (&this,*( s3.str+1))
//	char operator[](int index) {
//		return *(str + 1);
//	}  
//	//Mystring s4 = s1 + "newdata";
//	Mystring operator+(const char* str1) {
//		int n1 = strlen(str) + 1;
//		int n2 = strlen(str1) + 1;
//		char* p = new char[n1 + n2 + 3];
//		int i = 0, j = 0;
//		for (i = 0; str[i] != '\0'; i++) {
//			p[i] = str[i];
//		}
//		for (int j = 0; str1[j] != '\0'; j++) {
//			p[i] = str1[j];
//			i++;
//		}
//		return Mystring(p);
//	}
//	
//};
s5 ="newdata"+s1;	
//Mystring  operator+(const char*str1, const Mystring& s) {
//	
//}
//int main() {
//	Mystring s1{ "buling" };
//
//	/*Mystring s2 = {" samrter!"};
//	Mystring s3 = s1 + s2;*/
//	//Mystring s4 = s1 + "newdata";
//	/*char ch = s3[1];
//	s3.Print_str();
//	cout << ch << endl;*/
//	Mystring s5 ="newdata"+s1;	
//	s5.Print_str();
//
//	/*Mystring s6 = s1 += s2;*/
//	//s1.Print_str();
//	//s6.Print_str();
//
//	/*s4.Print_str();
//	s1.Print_str();
//	s2.Print_str();
//	s3.Print_str();*/
//}

15.普通的友元函数

#include <stddef.h>
#include<string.h>
#include<iostream>
#include<string>
using namespace std;
//整形类
class Int {
private:
	int value;
public:
	Int(int x) :value(x) {
	}
	//友元函数
	friend int operator+(int& x, const Int& a);
};
int operator+(int& x, const Int& a) {
	return x + a.value;
}
int main() {
	Int a{ 10 }, b{ 20 }, c{ 0 };
	int x = 5;
	x = x + a;
	cout << x << endl;
}

16.类友元

#include <stddef.h>
#include<string.h>
#include<iostream>
#include<string>
using namespace std;
//整形类
class Object;
class Int {
private:
	int value;
public:
	Int(int x) :value(x) {
	}
	void Print() {
		cout << value << endl;
	}
	friend class Object;;
};
class Object {
public:
	void  fun(Int &it) {
		it.value += 10;
	}
};
int main() {
	Int a{ 10 }, b{ 20 }, c{ 0 };
	int x = 5;
	Object obj;
	obj.fun(a);
	a.Print();
}

17.另一个类中的一个函数定义为友元函数

注意一定要将calss Int的声明写到object前面

#include <stddef.h>
#include<string.h>
#include<iostream>
#include<string>
using namespace std;
//整形类
class Int;
class Object {
public:
	void fun(Int& it);
};
class Int {
private:
	int value;
public:
	Int(int x) :value(x) {
	}
	void Print() {
		cout << value << endl;
	}
	friend void  Object::fun(Int& it);
};
void  Object::fun(Int& it) {
	it.value += 10;
}
int main() {
	Int a{ 10 }, b{ 20 }, c{ 0 };
	int x = 5;
	Object obj;
	obj.fun(a);
	a.Print();
}

18.C++中可以重载的符号

19.给贴贴汇报的作业152（Mystring）

#include <stddef.h>
#include<string.h>
#include<iostream>
#include<string>
using namespace std;
class Mystring {
private:
    char* str;
public:
    Mystring(const char* p = nullptr) :str(nullptr) {
        size_t n = strlen(p) + 1;
        str = new char[n];
        strcpy_s(str, n, p);
    }
    //(&c  this ,s)    c(s)  c=s
    Mystring(const Mystring& s) {
        size_t n = strlen(s.str) + 1;
        str = new char[n];
        strcpy_s(str, n, s.str);
    }
    ~Mystring() {
        if (str != nullptr) {
            delete[]str;
            str = nullptr;

        }
    }
    void Printf_str()
    {
        cout << this->str << endl;
    }
   /* Mystring operator+(const Mystring &s1) {
        size_t n1 = strlen(str) + 1;
        size_t n2 = strlen(s1.str) + 1;
        char* p = new char[n1 + n2+3];
        int i = 0, j = 0;
        for (i = 0; str[i] != '\0'; i++) {
            p[i] = str[i];
        }
        for (j = 0; s1.str[j] != '\0'; j++) {
            p[i] = s1.str[j];
            i++;
        }
        p[i] = '\0';
        return Mystring(p);
    }*/
    //s3 = s1 +"hello";(&s1,const char*p)
    Mystring operator+(const char* p) {
        size_t n1 = strlen(this->str) + 1;
        size_t n2 = strlen(p) + 1;
        char* ps = new char[n1 + n2 + 3];
        int i = 0, j = 0;
        for (i = 0; str[i] != '\0'; i++) {
            ps[i] = str[i];
        }
        for (j = 0; p[j] != '\0'; j++) {
            ps[i] = p[j];
            i++;
        }
        ps[i] = '\0';
        return Mystring(ps);
    }
    char* Str() {
        return  (this->str);
    }
    //a1+=s2   a1.+=(s2)
    Mystring& operator+=(const Mystring& s2) {
        size_t n1 = strlen(this->str)+1;
        size_t n2 = strlen(s2.str)+1;
        char* p = new char[n1+n2+3];
        int i = 0, j = 0;
        for (i = 0; str[i] != '\0'; i++)
        {
            p[i] = str[i];
        }
        for (j = 0; s2.str [j] != '\0'; j++)
        {
            p[i] = s2.str[j];
            i++;
        }
        p[i] = '\0';
        delete[]str;
        str = p;
        return *this;
    }
    //ch=s1[1]
    char operator[](int index) {
        return this->str[index];
    }
    //赋值运算符重载  s1=s2   s1.operator=(s2)   
    //operator=(&s1  this,s2);
    Mystring  operator=( Mystring& s2) {
        if (this != &s2) {
            delete[] str;
            size_t n = strlen(s2.str ) ;
            str = new char[n+1];
            strcpy_s(str, n, s2.str);
            
        }return *this;
    }
    /*Mystring& operator=(const Mystring& s) {
        		if (this != &s) {
        			size_t n = strlen(str) + 1;
        			delete[] str;
        			str = new char[n];
        			strcpy_s(str, n, s.str);
        			return *this;
        		}
        	}*/
    // s1[0] = 'x';   s1.operator[](int index,)
    //Mystring operator[]( int intdex, const char ch) {

    //}
};
//s3 = "hello" + s1;
//_________________________________________________________________________________________
Mystring operator+(const char* p, Mystring& s)
{
    size_t n1 = strlen(p) + 1;
    size_t n2 = strlen(s.Str()) + 1;
    char* ps = new char[n1 + n2 + 3];
    int i = 0, j = 0;
    for (i = 0; p[i] != '\0'; i++)
    {
        ps[i] = p[i];
    }
    for (j = 0; s.Str()[j] != '\0'; j++)
    {
        ps[i] = s.Str()[j];
        i++;
    }
    ps[i] = '\0';
    return Mystring(ps);
}

int main() {
    Mystring s1 = "jkfgfkd";
    Mystring s2=s1;
    s2.Printf_str();
  //  s1[0] = 'x';//s1.operator[](const char ch)
   // s1.Printf_str();
    //s2.Printf_str();
    //char ch = s1[1];//s1.operator[](int index)
    //cout << ch;
  //  Mystring s3 = s1 + s2;
    //  Mystring s3 = s1 +"hello";
    //Mystring s3 = "hello" + s1;
   /* s1 += s2
    s1.Printf_str();*/

   //s3.Printf_str();
}

20.浅赋值  浅拷贝

this.str=s1.str

21.在=运算符重载时应该判断this指针和&s地址是否相等

如：

if(this!=&s){
}

22.strcpy_s    strcat_s

在写函数时，应注意区分它两的使用方法

strcpy_s(ps,len ,str)

strcat_s(ps,len ,p)

23.Mystring 作业

#include <stddef.h>
#include<string.h>
#include<iostream>
#include<string>
using namespace std;
class Mystring {
private:
    char* str;
public:
    Mystring(const char* p = nullptr) :str(nullptr) {
        size_t n = strlen(p) + 1;
        str = new char[n];
        strcpy_s(str, n, p);
    }
    //(&c  this ,s)    c(s)  c=s
    Mystring(const Mystring& s) {
        size_t n = strlen(s.str) + 1;
        str = new char[n];
        strcpy_s(str, n, s.str);
    }
    ~Mystring() {
        if (str != nullptr) {
            delete[]str;
            str = nullptr;
        }
    }
    void Printf_str()
    {
        cout << this->str << endl;
    }
   /* Mystring operator+(const Mystring &s1) {
        size_t n1 = strlen(str) + 1;
        size_t n2 = strlen(s1.str) + 1;
        char* p = new char[n1 + n2+3];
        int i = 0, j = 0;
        for (i = 0; str[i] != '\0'; i++) {
            p[i] = str[i];
        }
        for (j = 0; s1.str[j] != '\0'; j++) {
            p[i] = s1.str[j];
            i++;
        }
        p[i] = '\0';
        return Mystring(p);
    }*/
    //s3 = s1 +"hello";(&s1,const char*p)
    Mystring operator+(const char* p) {
        size_t len = strlen(this->str) +strlen(p) + 1;
        char* ps = new char[len];
        strcpy_s(ps, len, str);
        strcat_s(ps, len, p);
        return Mystring(ps);
    }
    char* Str() const {
        return  (this->str);
    }
    //a1+=s2   a1.+=(s2)
    Mystring& operator+=(const Mystring& s2) {
        size_t n1 = strlen(this->str)+1;
        size_t n2 = strlen(s2.str)+1;
        char* p = new char[n1+n2+3];
        int i = 0, j = 0;
        for (i = 0; str[i] != '\0'; i++)
        {
            p[i] = str[i];
        }
        for (j = 0; s2.str [j] != '\0'; j++)
        {
            p[i] = s2.str[j];
            i++;
        }
        p[i] = '\0';
        delete[]str;
        str = p;
        return *this;
    }
    //ch=s1[1]
    char &operator[](int index) {
        return this->str[index];
    }
      
    //赋值运算符重载  s1=s2   s1.operator=(s2)   
    //operator=(&s1  this,s2);
    Mystring  operator=( Mystring& s2) {
        if (this != &s2) {
            delete[] str;
            size_t n = strlen(s2.str ) ;
            str = new char[n+1];
            strcpy_s(str, n, s2.str);
            
        }return *this;
    }
    /*Mystring& operator=(const Mystring& s) {
        		if (this != &s) {
        			size_t n = strlen(str) + 1;
        			delete[] str;
        			str = new char[n];
        			strcpy_s(str, n, s.str);
        			return *this;
        		}
        	}*/
    // s1[0] = 'x';   s1.operator[](int index,)
    //Mystring operator[]( int intdex, const char ch) {
    //friend iostream& operator<<(iostream& out, const Mystring& s);
    //}
};
//s3 = "hello" + s1;
//_________________________________________________________________________________________
Mystring operator+(const char* p, Mystring& s)
{
    size_t n1 = strlen(p) + 1;
    size_t n2 = strlen(s.Str()) + 1;
    char* ps = new char[n1 + n2 + 3];
    int i = 0, j = 0;
    for (i = 0; p[i] != '\0'; i++)
    {
        ps[i] = p[i];
    }
    for (j = 0; s.Str()[j] != '\0'; j++)
    {
        ps[i] = s.Str()[j];
        i++;
    }
    ps[i] = '\0';
    return Mystring(ps);
}
//编写输出流函数
//cout<<s2<<endl;
//operstor<<(cout,const Mystring &s)
ostream& operator<<(ostream& out,   const Mystring& s) {
    cout << s.Str();
    return out;
}
//输入流重载  cin<<s2   (istream &input,const Mystring &s2)
istream& operator>>(istream& input, const Mystring& s2) {
    cin >> s2.Str();
    return input;
}
int main() {
    const Mystring s1 = "jkfgfkd";
    Mystring s2="  sjhf";
    cin >> s2;
    cout << s2;
  //  s1[0] = 'x';//s1.operator[](const char ch)
  /* s1.Printf_str();
   s1[0] = 'g';
   s1.Printf_str();*/
   //s2.Printf_str();
    //s2.Printf_str();
    //char ch = s1[1];//s1.operator[](int index)
    //cout << ch;
   // Mystring s3 = s1 + s2;
    // Mystring s3 = s1 +"hello";
    //Mystring s3 = "hello" + s1;
   /* s1 += s2;
    s1.Printf_str();*/

   //s3.Printf_str();
}

24.想要通过cahr ch='g'来改变对象s 的值，在返回类型前加一个&就好了

   char &operator[](int index) {
        return this->str[index];
    }

25.创建 输入输出流  注意是ostream

   char* Str() const {
        return  (this->str);
    }
//——————————————————————————————————————————————————————————————————
    ostream& operator<<(ostream& out, const Mystring& s) {
        cout << s.Str();
        return out;
    }

26.新的 Mystring 类型

27.猫咪

#include <stddef.h>
#include<string.h>
#include<iostream>
#include<string>
using namespace std;
class Cat {
private:
	string _Owner;
	string _Name;
	static int num;
public:
	Cat(const string &p,const  string &ps) :_Owner(p), _Name(ps) {
		cout << "构造" << "     "<< ++num << endl;
	}
	Cat(const Cat& c) :_Owner(c._Owner ), _Name(c._Name  ) {
		cout<<"拷贝" << "     " << ++num << endl;
	}
	~Cat() {
		cout << "析构" << "     " << --num << endl;
	}
	void Print_Cat() {
		cout << "主人为" << this->_Owner <<endl<< "猫咪为" << this->_Name << endl << "num为" << this->num << endl;
	}
};
int Cat::num = 0;
int main() {
	Cat c1("xiao","fkhvn");
	c1.Print_Cat();

}

28.静态 成员

有以下几个特征：

（1）可以限制服务范围  如服务Cat类，并且存储在.data区中。

（2）不存在命名冲突，因为其是一个类中的变量，不具有透明性

（3）信息交流  如Cat类公用一个num

(4)常性+整形  可以直接在类中进行初始化（const  +  int   char   short   long long）

（5）静态成员的目的：信息共享、信息交流

（6）静态成员为一个类共享，不属于某个具体的实例

（7）当静态成员为公有时，可在别的函数中使用，使用方法：Cat::num=0;

(8)可以在类体中定义一个static静态对象，但是要在类外进行初始化

29.Circle 

#include <stddef.h>
#include<string.h>
#include<iostream>
#include<string>
using namespace std;
class Circle {
private:
	double r;
	static double pi;
public:
	Circle(double x) :r(x) {	}
	double Area() {
		return r * r * pi;
	}
	void Print() {
		cout << this->Area();
	}
};
double Circle::pi = 3.14;

int main() {
	Circle c1{ 3 };
	c1.Print();
}

30.类中不可定义一个对象

也不可以定义引用类型的对象

但是可以定义指针类型（如链表），以及静态类型（类中公用）

#include <stddef.h>
#include<string.h>
#include<iostream>
#include<string>
using namespace std;
class Int {
private:
	int value;
	Int* next;
public:
	Int(int x) :value(value), next(nullptr) {	}
	Int(const Int& c) :value(c.value ),next(c.next ) {}
	void Next( Int *p ) {
		p = next;
	}
};
int main() {
	Int a{ 3};
	Int b{ 4 };
	b.Next(&a);
	a.Next(nullptr);
}

31.在静态成员方法调用时，静态方法里面没有this指针  因此，其只能调用静态变量

调用方法：

Object c1(6);

(1)  c1.Show();

(2) Object :: Show();

32.静态方法          友元函数         普通方法

普通方法具有以下三种特征；

友元函数具有以下1特征；

静态方法具有以下1、2特征；

（1）访问类中的私有部分

（2）函数位于类的作用域中

（3）必须由一个类去激活

33.单例模式

有以下六步

（1）构造函数设为private

（2）删除  赋值重载  拷贝构造函数

（3）定义一个 静态对象

（4）在类外赋值

（5）写一个返回静态成员对象的方法

（6）建立一个对象，调用上一步写的方法  ，给新的对象赋值。

Int Int::a = 3;
static Int& Get_Static() {
	return a;
}
int main() {
	Int& tmp = Int::Get_Static();
}

34.

35.

36.

37.

038.

仗剑天涯津一
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
容器适配器之stack用法总结
陈实Yepper
12-23 1772
容器适配器是一个封装了序列容器的类模板，它在一般序列容器的基础上提供了一些不同的功能。之所以称作适配器类，是因为它可以通过适配容器现有的接口来提供不同的功能。 stack容器适配器中的数据是以 LIFO 的方式组织的，这和自助餐馆中堆叠的盘子、箱子中的一堆书类似。图 1 展示了一个理论上的 stack 容器及其一些基本操作。只能访问 stack 顶部的元素；只有在移除 stack 顶部的元素后，才...
C++实现进栈、出栈
m0_70940447的博客
06-11 1045
C++实现进栈、出栈
C语言、定义一个字符型链栈（使用Visual C++6.0编写）
m0_62659797的博客
10-22 1418
定义一个字符型链栈。 编写以下操作函数 初始化栈：函数名InitLinkStack(); 判别栈空：函数名IsEmptyStack(); 进栈：函数名Push(); 出栈：函数名Pop； 显示栈顶元素值：函数名DispStackTop()； 编写主函数：显示菜单，并可根据菜单命令调用相应操作函数。 要求： 不允许使用typedef char Data...
C++数据结构之栈
一个程序猿~
06-21 7371
栈的应用场景非常广泛，包括代码中的解析、数据结构中的树和图的遍历以及计算机系统中的内存分配等等。本文会介绍栈。
C++ 写一个栈stack
qq_45122293的博客
09-08 421
#include<iostream> using namespace std; class StackInt { public: StackInt(); /*{ size = 0; for (int& i : element) { i = 0; } }*/ int getSize() { return size; } int top()...
栈字符串
Alex117_2008的博客
08-11 427
分享一个小技术开始国泉的博客之旅。 ————————————————————我是分割线—————————————————————— 栈字符串是什么？ 　　是利用栈空间做存储，和c++ STL::string的区别在于前者的数据存储在栈上面后者在堆上面，替换std::string。 栈字符串的优势是什么？国泉认为比较最重要的是 　　1、栈是系统提供的数据结构（而堆是C++库提供）...
10-C++实现栈的常见操作
Hello Code
08-22 2127
栈分为顺序栈和链栈，顺序栈用数组实现，因为栈的先进后出特性，一般只考虑顺序栈。 代码1（自己写的）： #include &lt;iostream&gt; #include &lt;stdio.h&gt; #define ERR -9999999 const int maxn = 1000; using namespace std; typedef struct Stack{ in...
栈（c++实现）
echo_bright_的博客
03-01 1万+
  栈是一种特殊的线性表， 线性表是具有相同类型的n(n&gt;=0)个数据元素的有序(中间不能空位置)有限序列。   对栈的操作（增/删/读）只能通过栈的一端进行，允许操作的一端称之为栈顶，不允许操作的一端称为栈底。栈的特性为先进后出。c++实现栈，可采用如下的设计思路：   Stack是一个接口类，封装了栈的所有操作： //Stack.h #ifndef __STACK_H...
用c++实现一个简单栈
zzz的博客
04-10 8728
本文是在vs环境下用c++实现栈的操作 公司面试有时也会考栈的基本操作，因此基本功一定要打扎实 编写头文件 按照复旦大学c++课件教程编写栈的定义，编写一个Stack.h文件 下面是代码 #pragma once #include<iostream> using namespace std; template <typename Type>//模板函数，有效区域该声明下...
C++输入字符串的几种方式
热门推荐
柚子树's Blog
05-10 4万+
最近有复习到 C++ 基础知识，这里总结下在 C++ 中输入字符串的几种方式，有需要的可以参考： 1、cin >> void Cin1() //输入一个数字 { int a, b; cin >> a >> b; cout << "a + b = " << a + b << endl; } 运行结果： void ...
字符串匹配问题（栈）
有一种力量叫乐观
11-02 1795
字符串匹配问题 Time Limit : 3000/1000ms (Java/Other)   Memory Limit : 65535/32768K (Java/Other) Total Submission(s) : 1   Accepted Submission(s) : 1 Font: Times New Roman | Verdana | Georgia Font Size: ←
字符串堆栈和队列
清风明月
01-22 1047
<br />字符串堆栈程序<br /> <br />#!/user/bin/env python<br /> stack=[]<br /> def pushit():<br />     stack.append(raw_input('Enter New string:').strip())<br /> def popit():<br />     if len(stack)==0:<br />         print 'Cannot pop from an empt
c++输入字符串的多种方法总结
南国有佳人的博客
03-24 2万+
c++字符串输入
Ｃ语言中函数参数的入栈顺序
FrankieWang008的专栏
04-20 3908
对技术执着的人，比如说我，往往对一些问题，不仅想做到"知其然",还想做到"知其所以然".C语言可谓博大精深，即使我已经有多年的开发经验，可还是有许多问题不知其所以然。某天某地某人问我，C语言中函数参数的入栈顺序如何？从右至左，我随口回答。为什么是从右至左呢？我终究没有给出合理的解释。于是，只好做了个作业，于是有了这篇小博文。     #include     void foo（int x, i
c++和数据结构 模拟栈的入栈和出栈
苏苏爱自由
10-09 6823
c++学了类   老师就让写了这个、、、 #include #include using namespace std; class Stack { public: void push(int x); void init(); int pop(); struct stack { int num; stack *next ,*pre; }*head; };
C++实现栈的基本操作（入栈，出栈，取栈顶）
weixin_46685611的博客
03-07 4721
C++实现栈的基本操作（入栈，出栈，取栈顶）
c语言字符串如何压入栈,【C语言】利用栈将数组中字符串逆序
weixin_31960145的博客
05-19 1766
该楼层疑似违规已被系统折叠隐藏此楼查看此楼#include"stdio.h"#include"stdlib.h"#define STACK_INIT_SIZE 100#define STACKINCREMENT 10typedef struct{char *base;char *top;int stacksize;}SqStack;main(){SqStack S;char a[4];int i...
c++ 栈和栈的应用（图解）
qq_62309585的博客
09-08 5057
图解 栈 后缀表达式等
c++栈
chengmoling的博客
03-28 367
在c++中pop 操作和top操作
c++将字符串存入栈
最新发布
10-04
c可以使用字符数组来存储字符串，并将其存储在栈中。在C中，字符串是由字符数组表示的，以null字符'\0'作为结束标志。下面是将字符串存储在栈中的示例代码： ```c #include <stdio.h> int main() { char str[] = "Hello, world!"; // 字符数组存储字符串 printf("str: %s\n", str); return 0; } ``` 在上面的代码中，我们声明了一个字符数组`str`来存储字符串"Hello, world!"。该字符数组会被存储在栈中，并且以null字符结尾。通过`printf`函数输出字符串`str`。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值